Gtk224 = Gtk224 or {}
Gtk224.__version_no__ = "Gtk224"
Gtk224.__module_name__ = "gtk+-2.0"

----  [Gtk interfaces] Start ... 
---------------------  GtkActivatable
Gtk224.GtkActivatable = {
  class = "GtkActivatable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    sync_action_properties = {"void", {"GtkActivatable*", "GtkAction*"}, {"activatable", "action"} }, 
    update                 = {"void", {"GtkActivatable*", "GtkAction*", "const gchar*"}, {"activatable", "action", "property_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    related_action        = {__type__="GtkAction*"                       , __gencode__ = {"gtk_activatable_set_related_action((GtkActivatable*)({* id *}), (GtkAction*)({* property.value *}))"} },
    use_action_appearance = {__type__="gboolean"   ,__default__ = "TRUE" , __gencode__ = {"gtk_activatable_set_use_action_appearance((GtkActivatable*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkBuildable
Gtk224.GtkBuildable = {
  class = "GtkBuildable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_child              = {"void"        , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*"}, {"buildable", "builder", "child", "type"} }, 
    construct_child        = {"GObject*"    , {"GtkBuildable*", "GtkBuilder*", "const gchar*"}, {"buildable", "builder", "name"} }, 
    custom_finished        = {"void"        , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*", "gpointer"}, {"buildable", "builder", "child", "tagname", "data"} }, 
    custom_tag_end         = {"void"        , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*", "gpointer*"}, {"buildable", "builder", "child", "tagname", "data"} }, 
    custom_tag_start       = {"gboolean"    , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*", "GMarkupParser*", "gpointer*"}, {"buildable", "builder", "child", "tagname", "parser", "data"} }, 
    get_internal_child     = {"GObject*"    , {"GtkBuildable*", "GtkBuilder*", "const gchar*"}, {"buildable", "builder", "childname"} }, 
    get_name               = {"const gchar*", {"GtkBuildable*"}, {"buildable"} }, 
    parser_finished        = {"void"        , {"GtkBuildable*", "GtkBuilder*"}, {"buildable", "builder"} }, 
    set_buildable_property = {"void"        , {"GtkBuildable*", "GtkBuilder*", "const gchar*", "const GValue*"}, {"buildable", "builder", "name", "value"} }, 
    set_name               = {"void"        , {"GtkBuildable*", "const gchar*"}, {"buildable", "name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkCellEditable
Gtk224.GtkCellEditable = {
  class = "GtkCellEditable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    editing_done  = {"void", {"GtkCellEditable*"}, {"cell_editable"} }, 
    remove_widget = {"void", {"GtkCellEditable*"}, {"cell_editable"} }, 
    start_editing = {"void", {"GtkCellEditable*", "GdkEvent*"}, {"cell_editable", "event"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['editing-done']  = {ret_type = "void", params = {type = {"GtkCellEditable*"}, name ={"celleditable"}} }, 
    ['remove-widget'] = {ret_type = "void", params = {type = {"GtkCellEditable*"}, name ={"celleditable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    editing_canceled = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkCellLayout
Gtk224.GtkCellLayout = {
  class = "GtkCellLayout", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_attribute      = {"void"  , {"GtkCellLayout*", "GtkCellRenderer*", "const gchar*", "gint"}, {"cell_layout", "cell", "attribute", "column"} }, 
    clear              = {"void"  , {"GtkCellLayout*"}, {"cell_layout"} }, 
    clear_attributes   = {"void"  , {"GtkCellLayout*", "GtkCellRenderer*"}, {"cell_layout", "cell"} }, 
    get_cells          = {"GList*", {"GtkCellLayout*"}, {"cell_layout"} }, 
    pack_end           = {"void"  , {"GtkCellLayout*", "GtkCellRenderer*", "gboolean"}, {"cell_layout", "cell", "expand"} }, 
    pack_start         = {"void"  , {"GtkCellLayout*", "GtkCellRenderer*", "gboolean"}, {"cell_layout", "cell", "expand"} }, 
    reorder            = {"void"  , {"GtkCellLayout*", "GtkCellRenderer*", "gint"}, {"cell_layout", "cell", "position"} }, 
    set_cell_data_func = {"void"  , {"GtkCellLayout*", "GtkCellRenderer*", "GtkCellLayoutDataFunc", "gpointer", "GDestroyNotify"}, {"cell_layout", "cell", "func", "func_data", "destroy"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkEditable
Gtk224.GtkEditable = {
  class = "GtkEditable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed         = {ret_type = "void", params = {type = {"GtkEditable*"}, name ={"editable"}} }, 
    ['delete-text'] = {ret_type = "void", params = {type = {"GtkEditable*", "gint", "gint"}, name ={"editable", "start_pos", "end_pos"}} }, 
    ['insert-text'] = {ret_type = "void", params = {type = {"GtkEditable*", "gchar*", "gint", "gpointer"}, name ={"editable", "new_text", "new_text_length", "position"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkFileChooser
Gtk224.GtkFileChooser = {
  class = "GtkFileChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['confirm-overwrite']      = {ret_type = "{FileChooserConfirmation}", params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['current-folder-changed'] = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['file-activated']         = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['selection-changed']      = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['update-preview']         = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    action                    = {__type__="GtkFileChooserAction" ,__default__ = "GTK_FILE_CHOOSER_ACTION_OPEN" , __gencode__ = {"gtk_file_chooser_set_action((GtkFileChooser*)({* id *}), (GtkFileChooserAction)({* property.value *}))"} },
    create_folders            = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_create_folders((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    do_overwrite_confirmation = {__type__="gboolean"             ,__default__ = "FALSE"                        , __gencode__ = {"gtk_file_chooser_set_do_overwrite_confirmation((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    extra_widget              = {__type__="GtkWidget*"                                                         , __gencode__ = {"gtk_file_chooser_set_extra_widget((GtkFileChooser*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    file_system_backend       = {__type__="gchar*"               ,__default__ = "NULL"                         ,rwflags="w" },
    filter                    = {__type__="GtkFileFilter*"                                                     , __gencode__ = {"gtk_file_chooser_set_filter((GtkFileChooser*)({* id *}), (GtkFileFilter*)({* property.value *}))"} },
    local_only                = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_local_only((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    preview_widget            = {__type__="GtkWidget*"                                                         , __gencode__ = {"gtk_file_chooser_set_preview_widget((GtkFileChooser*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    preview_widget_active     = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_preview_widget_active((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    select_multiple           = {__type__="gboolean"             ,__default__ = "FALSE"                        , __gencode__ = {"gtk_file_chooser_set_select_multiple((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    show_hidden               = {__type__="gboolean"             ,__default__ = "FALSE"                        , __gencode__ = {"gtk_file_chooser_set_show_hidden((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    use_preview_label         = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_use_preview_label((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkOrientable
Gtk224.GtkOrientable = {
  class = "GtkOrientable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    orientation = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_HORIZONTAL" , __gencode__ = {"gtk_orientable_set_orientation((GtkOrientable*)({* id *}), (GtkOrientation)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkPrintOperationPreview
Gtk224.GtkPrintOperationPreview = {
  class = "GtkPrintOperationPreview", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    end_preview   = {"void"    , {"GtkPrintOperationPreview*"}, {"preview"} }, 
    got_page_size = {"void"    , {"GtkPrintOperationPreview*", "GtkPrintContext*", "GtkPageSetup*"}, {"preview", "context", "page_setup"} }, 
    is_selected   = {"gboolean", {"GtkPrintOperationPreview*", "gint"}, {"preview", "page_nr"} }, 
    ready         = {"void"    , {"GtkPrintOperationPreview*", "GtkPrintContext*"}, {"preview", "context"} }, 
    render_page   = {"void"    , {"GtkPrintOperationPreview*", "gint"}, {"preview", "page_nr"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['got-page-size'] = {ret_type = "void", params = {type = {"GtkPrintOperationPreview*", "GtkPrintContext*", "GtkPageSetup*"}, name ={"printoperationpreview", "context", "page_setup"}} }, 
    ready             = {ret_type = "void", params = {type = {"GtkPrintOperationPreview*", "GtkPrintContext*"}, name ={"preview", "context"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkRecentChooser
Gtk224.GtkRecentChooser = {
  class = "GtkRecentChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_filter         = {"void"             , {"GtkRecentChooser*", "GtkRecentFilter*"}, {"chooser", "filter"} }, 
    get_current_uri    = {"gchar*"           , {"GtkRecentChooser*"}, {"chooser"} }, 
    get_items          = {"GList*"           , {"GtkRecentChooser*"}, {"chooser"} }, 
    get_recent_manager = {"GtkRecentManager*", {"GtkRecentChooser*"}, {"chooser"} }, 
    item_activated     = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    list_filters       = {"GSList*"          , {"GtkRecentChooser*"}, {"chooser"} }, 
    remove_filter      = {"void"             , {"GtkRecentChooser*", "GtkRecentFilter*"}, {"chooser", "filter"} }, 
    select_all         = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    select_uri         = {"gboolean"         , {"GtkRecentChooser*", "const gchar*"}, {"chooser", "uri"} }, 
    selection_changed  = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    set_current_uri    = {"gboolean"         , {"GtkRecentChooser*", "const gchar*"}, {"chooser", "uri"} }, 
    set_sort_func      = {"void"             , {"GtkRecentChooser*", "GtkRecentSortFunc", "gpointer", "GDestroyNotify"}, {"chooser", "sort_func", "data", "destroy"} }, 
    unselect_all       = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    unselect_uri       = {"void"             , {"GtkRecentChooser*", "const gchar*"}, {"chooser", "uri"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['item-activated']    = {ret_type = "void", params = {type = {"GtkRecentChooser*"}, name ={"recentchooser"}} }, 
    ['selection-changed'] = {ret_type = "void", params = {type = {"GtkRecentChooser*"}, name ={"recentchooser"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filter          = {__type__="GtkRecentFilter*"                                        , __gencode__ = {"gtk_recent_chooser_set_filter((GtkRecentChooser*)({* id *}), (GtkRecentFilter*)({* property.value *}))"} },
    limit           = {__type__="gint"              ,__default__ = "-1"                   , __gencode__ = {"gtk_recent_chooser_set_limit((GtkRecentChooser*)({* id *}), (gint)({* property.value *}))"} },
    local_only      = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_recent_chooser_set_local_only((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    recent_manager  = {__type__="GtkRecentManager*"                                       ,rwflags="w" },
    select_multiple = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_recent_chooser_set_select_multiple((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    show_icons      = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_recent_chooser_set_show_icons((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    show_not_found  = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_recent_chooser_set_show_not_found((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    show_private    = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_recent_chooser_set_show_private((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    show_tips       = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_recent_chooser_set_show_tips((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    sort_type       = {__type__="GtkRecentSortType" ,__default__ = "GTK_RECENT_SORT_NONE" , __gencode__ = {"gtk_recent_chooser_set_sort_type((GtkRecentChooser*)({* id *}), (GtkRecentSortType)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkToolShell
Gtk224.GtkToolShell = {
  class = "GtkToolShell", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_ellipsize_mode   = {"PangoEllipsizeMode", {"GtkToolShell*"}, {"shell"} }, 
    get_icon_size        = {"GtkIconSize"       , {"GtkToolShell*"}, {"shell"} }, 
    get_orientation      = {"GtkOrientation"    , {"GtkToolShell*"}, {"shell"} }, 
    get_relief_style     = {"GtkReliefStyle"    , {"GtkToolShell*"}, {"shell"} }, 
    get_style            = {"GtkToolbarStyle"   , {"GtkToolShell*"}, {"shell"} }, 
    get_text_alignment   = {"gfloat"            , {"GtkToolShell*"}, {"shell"} }, 
    get_text_orientation = {"GtkOrientation"    , {"GtkToolShell*"}, {"shell"} }, 
    get_text_size_group  = {"GtkSizeGroup*"     , {"GtkToolShell*"}, {"shell"} }, 
    rebuild_menu         = {"void"              , {"GtkToolShell*"}, {"shell"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeDragDest
Gtk224.GtkTreeDragDest = {
  class = "GtkTreeDragDest", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    drag_data_received = {"gboolean", {"GtkTreeDragDest*", "GtkTreePath*", "GtkSelectionData*"}, {"drag_dest", "dest", "selection_data"} }, 
    row_drop_possible  = {"gboolean", {"GtkTreeDragDest*", "GtkTreePath*", "GtkSelectionData*"}, {"drag_dest", "dest_path", "selection_data"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeDragSource
Gtk224.GtkTreeDragSource = {
  class = "GtkTreeDragSource", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    drag_data_delete = {"gboolean", {"GtkTreeDragSource*", "GtkTreePath*"}, {"drag_source", "path"} }, 
    drag_data_get    = {"gboolean", {"GtkTreeDragSource*", "GtkTreePath*", "GtkSelectionData*"}, {"drag_source", "path", "selection_data"} }, 
    row_draggable    = {"gboolean", {"GtkTreeDragSource*", "GtkTreePath*"}, {"drag_source", "path"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeModel
Gtk224.GtkTreeModel = {
  class = "GtkTreeModel", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_column_type       = {"GType"            , {"GtkTreeModel*", "gint"}, {"tree_model", "index_"} }, 
    get_flags             = {"GtkTreeModelFlags", {"GtkTreeModel*"}, {"tree_model"} }, 
    get_iter              = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_model", "iter", "path"} }, 
    get_n_columns         = {"gint"             , {"GtkTreeModel*"}, {"tree_model"} }, 
    get_path              = {"GtkTreePath*"     , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    get_value             = {"void"             , {"GtkTreeModel*", "GtkTreeIter*", "gint", "GValue*"}, {"tree_model", "iter", "column", "value"} }, 
    iter_children         = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*"}, {"tree_model", "iter", "parent"} }, 
    iter_has_child        = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_n_children       = {"gint"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_next             = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_nth_child        = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*", "gint"}, {"tree_model", "iter", "parent", "n"} }, 
    iter_parent           = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*"}, {"tree_model", "iter", "child"} }, 
    ref_node              = {"void"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    row_changed           = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    row_deleted           = {"void"             , {"GtkTreeModel*", "GtkTreePath*"}, {"tree_model", "path"} }, 
    row_has_child_toggled = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    row_inserted          = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    rows_reordered        = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*", "gint*"}, {"tree_model", "path", "iter", "new_order"} }, 
    unref_node            = {"void"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['row-changed']           = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['row-deleted']           = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*"}, name ={"treemodel", "path"}} }, 
    ['row-has-child-toggled'] = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['row-inserted']          = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['rows-reordered']        = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*", "gpointer"}, name ={"treemodel", "path", "iter", "new_order"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeSortable
Gtk224.GtkTreeSortable = {
  class = "GtkTreeSortable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_sort_column_id    = {"gboolean", {"GtkTreeSortable*", "gint*", "GtkSortType*"}, {"sortable", "sort_column_id", "order"} }, 
    has_default_sort_func = {"gboolean", {"GtkTreeSortable*"}, {"sortable"} }, 
    set_default_sort_func = {"void"    , {"GtkTreeSortable*", "GtkTreeIterCompareFunc", "gpointer", "GDestroyNotify"}, {"sortable", "func", "data", "destroy"} }, 
    set_sort_column_id    = {"void"    , {"GtkTreeSortable*", "gint", "GtkSortType"}, {"sortable", "sort_column_id", "order"} }, 
    set_sort_func         = {"void"    , {"GtkTreeSortable*", "gint", "GtkTreeIterCompareFunc", "gpointer", "GDestroyNotify"}, {"sortable", "sort_column_id", "func", "data", "destroy"} }, 
    sort_column_changed   = {"void"    , {"GtkTreeSortable*"}, {"sortable"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['sort-column-changed'] = {ret_type = "void", params = {type = {"GtkTreeSortable*"}, name ={"treesortable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

----  [Gtk interfaces] End ... 
----  [Gtk Classes] Start 
---------------------  GtkAccelGroup
Gtk224.GtkAccelGroup = {
  class = "GtkAccelGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_accel_group_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    accel_changed = {"void", {"GtkAccelGroup*", "guint", "GdkModifierType", "GClosure*"}, {"accel_group", "keyval", "modifier", "accel_closure"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accel-activate'] = {ret_type = "gboolean", params = {type = {"GtkAccelGroup*", "GObject*", "guint", "GdkModifierType*"}, name ={"accelgroup", "acceleratable", "keyval", "modifier"}} }, 
    ['accel-changed']  = {ret_type = "void"    , params = {type = {"GtkAccelGroup*", "guint", "GdkModifierType*", "GClosure*"}, name ={"accelgroup", "keyval", "modifier", "accel_closure"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    is_locked     = {__type__="gboolean"         ,__default__ = "FALSE"                                                                                                },
    modifier_mask = {__type__="GdkModifierType*" ,__default__ = "GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK"  },
  },
  parent = nil, 
};

---------------------  GtkAccelMap
Gtk224.GtkAccelMap = {
  class = "GtkAccelMap", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkAccelMap*", "gchar*", "guint", "GdkModifierType*"}, name ={"accelmap", "accel_path", "accel_key", "accel_mods"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkAccessible
Gtk224.GtkAccessible = {
  class = "GtkAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    connect_widget_destroyed = {"void", {"GtkAccessible*"}, {"accessible"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkAction
Gtk224.GtkAction = {
  class = "GtkAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this.stock_id.value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock_id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate         = {"void"      , {"GtkAction*"}, {"action"} }, 
    connect_proxy    = {"void"      , {"GtkAction*", "GtkWidget*"}, {"action", "proxy"} }, 
    create_menu      = {"GtkWidget*", {"GtkAction*"}, {"action"} }, 
    create_menu_item = {"GtkWidget*", {"GtkAction*"}, {"action"} }, 
    create_tool_item = {"GtkWidget*", {"GtkAction*"}, {"action"} }, 
    disconnect_proxy = {"void"      , {"GtkAction*", "GtkWidget*"}, {"action", "proxy"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkAction*"}, name ={"action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    action_group       = {__type__="GtkActionGroup*"                        ,rwflags="rw" },
    always_show_image  = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_action_set_always_show_image((GtkAction*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    gicon              = {__type__="GIcon*"                                 , __gencode__ = {"gtk_action_set_gicon((GtkAction*)({* id *}), (GIcon*)({* property.value *}))"} },
    hide_if_empty      = {__type__="gboolean"        ,__default__ = "TRUE"  ,rwflags="rw" },
    icon_name          = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_icon_name((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    is_important       = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_action_set_is_important((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    label              = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_label((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    name               = {__type__="gchar*"          ,__default__ = "NULL"  ,rwflags="rw" },
    sensitive          = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_sensitive((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    short_label        = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_short_label((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    stock_id           = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_stock_id((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    tooltip            = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_tooltip((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    visible            = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_visible((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    visible_horizontal = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_visible_horizontal((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    visible_overflown  = {__type__="gboolean"        ,__default__ = "TRUE"  ,rwflags="rw" },
    visible_vertical   = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_visible_vertical((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkActionGroup
Gtk224.GtkActionGroup = {
  class = "GtkActionGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_action_group_new((const gchar*)({* this.name.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"name"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_action = {"GtkAction*", {"GtkActionGroup*", "const gchar*"}, {"action_group", "action_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['connect-proxy']    = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*", "GtkWidget*"}, name ={"actiongroup", "action", "proxy"}} }, 
    ['disconnect-proxy'] = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*", "GtkWidget*"}, name ={"actiongroup", "action", "proxy"}} }, 
    ['post-activate']    = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*"}, name ={"actiongroup", "action"}} }, 
    ['pre-activate']     = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*"}, name ={"actiongroup", "action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    name      = {__type__="gchar*"   ,__default__ = "NULL" ,rwflags="rw" },
    sensitive = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_action_group_set_sensitive((GtkActionGroup*)({* id *}), (gboolean)({* property.value *}))"} },
    visible   = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_action_group_set_visible((GtkActionGroup*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkBuilder
Gtk224.GtkBuilder = {
  class = "GtkBuilder", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_builder_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_type_from_name = {"GType", {"GtkBuilder*", "const char*"}, {"builder", "type_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    translation_domain = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_builder_set_translation_domain((GtkBuilder*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkClipboard
Gtk224.GtkClipboard = {
  class = "GtkClipboard", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['owner-change'] = {ret_type = "void", params = {type = {"GtkClipboard*", "GdkEvent*"}, name ={"clipboard", "event"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkEntryBuffer
Gtk224.GtkEntryBuffer = {
  class = "GtkEntryBuffer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_entry_buffer_new((const gchar*)({* this.initial_chars.value *}), (gint)({* this.n_initial_chars.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    delete_text   = {"guint"       , {"GtkEntryBuffer*", "guint", "guint"}, {"buffer", "position", "n_chars"} }, 
    deleted_text  = {"void"        , {"GtkEntryBuffer*", "guint", "guint"}, {"buffer", "position", "n_chars"} }, 
    get_length    = {"guint"       , {"GtkEntryBuffer*"}, {"buffer"} }, 
    get_text      = {"const gchar*", {"GtkEntryBuffer*", "gsize*"}, {"buffer", "n_bytes"} }, 
    insert_text   = {"guint"       , {"GtkEntryBuffer*", "guint", "const gchar*", "guint"}, {"buffer", "position", "chars", "n_chars"} }, 
    inserted_text = {"void"        , {"GtkEntryBuffer*", "guint", "const gchar*", "guint"}, {"buffer", "position", "chars", "n_chars"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['deleted-text']  = {ret_type = "void", params = {type = {"GtkEntryBuffer*", "guint", "guint"}, name ={"entrybuffer", "position", "n_chars"}} }, 
    ['inserted-text'] = {ret_type = "void", params = {type = {"GtkEntryBuffer*", "guint", "gchar*", "guint"}, name ={"entrybuffer", "position", "chars", "n_chars"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    length     = {__type__="guint"  ,__default__ = "0"     },
    max_length = {__type__="gint"   ,__default__ = "0"    , __gencode__ = {"gtk_entry_buffer_set_max_length((GtkEntryBuffer*)({* id *}), (gint)({* property.value *}))"} },
    text       = {__type__="gchar*" ,__default__ = "\"\"" , __gencode__ = {"gtk_entry_buffer_set_text((GtkEntryBuffer*)({* id *}), (const gchar*)({* property.value *}), (gint)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkEntryCompletion
Gtk224.GtkEntryCompletion = {
  class = "GtkEntryCompletion", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_entry_completion_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    action_activated = {"void"    , {"GtkEntryCompletion*", "gint"}, {"completion", "index_"} }, 
    cursor_on_match  = {"gboolean", {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, {"completion", "model", "iter"} }, 
    insert_prefix    = {"gboolean", {"GtkEntryCompletion*", "const gchar*"}, {"completion", "prefix"} }, 
    match_selected   = {"gboolean", {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, {"completion", "model", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['action-activated'] = {ret_type = "void"    , params = {type = {"GtkEntryCompletion*", "gint"}, name ={"entrycompletion", "index"}} }, 
    ['cursor-on-match']  = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, name ={"entrycompletion", "model", "iter"}} }, 
    ['insert-prefix']    = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "gchar*"}, name ={"entrycompletion", "prefix"}} }, 
    ['match-selected']   = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, name ={"entrycompletion", "model", "iter"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    inline_completion  = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_entry_completion_set_inline_completion((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    inline_selection   = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_entry_completion_set_inline_selection((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    minimum_key_length = {__type__="gint"          ,__default__ = "1"     , __gencode__ = {"gtk_entry_completion_set_minimum_key_length((GtkEntryCompletion*)({* id *}), (gint)({* property.value *}))"} },
    model              = {__type__="GtkTreeModel*"                        , __gencode__ = {"gtk_entry_completion_set_model((GtkEntryCompletion*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    popup_completion   = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_completion((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    popup_set_width    = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_set_width((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    popup_single_match = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_single_match((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    text_column        = {__type__="gint"          ,__default__ = "-1"    , __gencode__ = {"gtk_entry_completion_set_text_column((GtkEntryCompletion*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellLayout}, 
};

---------------------  GtkIMContext
Gtk224.GtkIMContext = {
  class = "GtkIMContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    commit               = {"void"    , {"GtkIMContext*", "const gchar*"}, {"context", "str"} }, 
    delete_surrounding   = {"gboolean", {"GtkIMContext*", "gint", "gint"}, {"context", "offset", "n_chars"} }, 
    filter_keypress      = {"gboolean", {"GtkIMContext*", "GdkEventKey*"}, {"context", "event"} }, 
    focus_in             = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    focus_out            = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    get_preedit_string   = {"void"    , {"GtkIMContext*", "gchar**", "PangoAttrList**", "gint*"}, {"context", "str", "attrs", "cursor_pos"} }, 
    get_surrounding      = {"gboolean", {"GtkIMContext*", "gchar**", "gint*"}, {"context", "text", "cursor_index"} }, 
    preedit_changed      = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    preedit_end          = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    preedit_start        = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    reset                = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    retrieve_surrounding = {"gboolean", {"GtkIMContext*"}, {"context"} }, 
    set_client_window    = {"void"    , {"GtkIMContext*", "GdkWindow*"}, {"context", "window"} }, 
    set_cursor_location  = {"void"    , {"GtkIMContext*", "GdkRectangle*"}, {"context", "area"} }, 
    set_surrounding      = {"void"    , {"GtkIMContext*", "const gchar*", "gint", "gint"}, {"context", "text", "len", "cursor_index"} }, 
    set_use_preedit      = {"void"    , {"GtkIMContext*", "gboolean"}, {"context", "use_preedit"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    commit                   = {ret_type = "void"    , params = {type = {"GtkIMContext*", "const gchar*"}, name ={"context", "str"}} }, 
    ['delete-surrounding']   = {ret_type = "gboolean", params = {type = {"GtkIMContext*", "gint", "gint"}, name ={"imcontext", "offset", "n_chars"}} }, 
    ['preedit-changed']      = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['preedit-end']          = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['preedit-start']        = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['retrieve-surrounding'] = {ret_type = "gboolean", params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkIconFactory
Gtk224.GtkIconFactory = {
  class = "GtkIconFactory", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_icon_factory_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkIconTheme
Gtk224.GtkIconTheme = {
  class = "GtkIconTheme", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_icon_theme_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkIconTheme*"}, {"icon_theme"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkIconTheme*"}, name ={"icon_theme"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkIdentifier
Gtk224.GtkIdentifier = {
  class = "GtkIdentifier", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkListStore
Gtk224.GtkListStore = {
  class = "GtkListStore", 
  constructor = { 
    -- 名称[- ==> _], 
    new  = { gencode = "gtk_list_store_new((gint)({* this.n_columns.value *}), 0)", 
            params = { type = {}, name = {} } },
    newv = { gencode = "gtk_list_store_newv((gint)({* this.n_columns.value *}), (GType*)({* this.types.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable, Gtk224.GtkTreeDragDest, Gtk224.GtkTreeDragSource, Gtk224.GtkTreeModel, Gtk224.GtkTreeSortable}, 
};

---------------------  GtkMountOperation
Gtk224.GtkMountOperation = {
  class = "GtkMountOperation", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_mount_operation_new((GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"GtkWindow*"}, 
                       name = {"parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    is_showing = {__type__="gboolean"   ,__default__ = "FALSE"  },
    parent     = {__type__="GtkWindow*"                        , __gencode__ = {"gtk_mount_operation_set_parent((GtkMountOperation*)({* id *}), (GtkWindow*)({* property.value *}))"} },
    screen     = {__type__="GdkScreen*"                        , __gencode__ = {"gtk_mount_operation_set_screen((GtkMountOperation*)({* id *}), (GdkScreen*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkObject
Gtk224.GtkObject = {
  class = "GtkObject", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_object_new((GType)({* this.type.value *}), (const gchar*)({* this.first_property_name.value *}), 0)", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    destroy = {"void", {"GtkObject*"}, {"object"} }, 
    get_arg = {"void", {"GtkObject*", "GtkArg*", "guint"}, {"object", "arg", "arg_id"} }, 
    set_arg = {"void", {"GtkObject*", "GtkArg*", "guint"}, {"object", "arg", "arg_id"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    destroy = {ret_type = "void", params = {type = {"GtkObject*"}, name ={"object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    user_data = {__type__="gpointer" , __gencode__ = {"gtk_object_set_user_data((GtkObject*)({* id *}), (gpointer)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkPageSetup
Gtk224.GtkPageSetup = {
  class = "GtkPageSetup", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_page_setup_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_page_setup_new_from_file((const gchar*)({* this.file_name.value *}))", 
            params = { type = {}, name = {} } },
    new_from_key_file = { gencode = "gtk_page_setup_new_from_key_file((GKeyFile*)({* this.key_file.value *}), (const gchar*)({* this.group_name.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkPrintContext
Gtk224.GtkPrintContext = {
  class = "GtkPrintContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkPrintOperation
Gtk224.GtkPrintOperation = {
  class = "GtkPrintOperation", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_operation_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    begin_print          = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    create_custom_widget = {"GtkWidget*", {"GtkPrintOperation*"}, {"operation"} }, 
    custom_widget_apply  = {"void"      , {"GtkPrintOperation*", "GtkWidget*"}, {"operation", "widget"} }, 
    done                 = {"void"      , {"GtkPrintOperation*", "GtkPrintOperationResult"}, {"operation", "result"} }, 
    draw_page            = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*", "gint"}, {"operation", "context", "page_nr"} }, 
    end_print            = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    paginate             = {"gboolean"  , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    preview              = {"gboolean"  , {"GtkPrintOperation*", "GtkPrintOperationPreview*", "GtkPrintContext*", "GtkWindow*"}, {"operation", "preview", "context", "parent"} }, 
    request_page_setup   = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*", "gint", "GtkPageSetup*"}, {"operation", "context", "page_nr", "setup"} }, 
    status_changed       = {"void"      , {"GtkPrintOperation*"}, {"operation"} }, 
    update_custom_widget = {"void"      , {"GtkPrintOperation*", "GtkWidget*", "GtkPageSetup*", "GtkPrintSettings*"}, {"operation", "widget", "setup", "settings"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['begin-print']          = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"printoperation", "context"}} }, 
    ['create-custom-widget'] = {ret_type = "GObject*", params = {type = {"GtkPrintOperation*"}, name ={"printoperation"}} }, 
    ['custom-widget-apply']  = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkWidget*"}, name ={"printoperation", "widget"}} }, 
    done                     = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintOperationResult"}, name ={"operation", "result"}} }, 
    ['draw-page']            = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*", "gint"}, name ={"printoperation", "context", "page_nr"}} }, 
    ['end-print']            = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"printoperation", "context"}} }, 
    paginate                 = {ret_type = "gboolean", params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"operation", "context"}} }, 
    preview                  = {ret_type = "gboolean", params = {type = {"GtkPrintOperation*", "GtkPrintOperationPreview*", "GtkPrintContext*", "GtkWindow*"}, name ={"operation", "preview", "context", "parent"}} }, 
    ['request-page-setup']   = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*", "gint", "GtkPageSetup*"}, name ={"printoperation", "context", "page_nr", "setup"}} }, 
    ['status-changed']       = {ret_type = "void"    , params = {type = {"GtkPrintOperation*"}, name ={"printoperation"}} }, 
    ['update-custom-widget'] = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkWidget*", "GtkPageSetup*", "GtkPrintSettings*"}, name ={"printoperation", "widget", "setup", "settings"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    allow_async        = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_allow_async((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    current_page       = {__type__="gint"              ,__default__ = "-1"                       , __gencode__ = {"gtk_print_operation_set_current_page((GtkPrintOperation*)({* id *}), (gint)({* property.value *}))"} },
    custom_tab_label   = {__type__="gchar*"            ,__default__ = "NULL"                     , __gencode__ = {"gtk_print_operation_set_custom_tab_label((GtkPrintOperation*)({* id *}), (const gchar*)({* property.value *}))"} },
    default_page_setup = {__type__="GtkPageSetup*"                                               , __gencode__ = {"gtk_print_operation_set_default_page_setup((GtkPrintOperation*)({* id *}), (GtkPageSetup*)({* property.value *}))"} },
    embed_page_setup   = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_embed_page_setup((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    export_filename    = {__type__="gchar*"            ,__default__ = "NULL"                     , __gencode__ = {"gtk_print_operation_set_export_filename((GtkPrintOperation*)({* id *}), (const gchar*)({* property.value *}))"} },
    has_selection      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_has_selection((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    job_name           = {__type__="gchar*"            ,__default__ = "\"\""                     , __gencode__ = {"gtk_print_operation_set_job_name((GtkPrintOperation*)({* id *}), (const gchar*)({* property.value *}))"} },
    n_pages            = {__type__="gint"              ,__default__ = "-1"                       , __gencode__ = {"gtk_print_operation_set_n_pages((GtkPrintOperation*)({* id *}), (gint)({* property.value *}))"} },
    n_pages_to_print   = {__type__="gint"              ,__default__ = "-1"                        },
    print_settings     = {__type__="GtkPrintSettings*"                                           , __gencode__ = {"gtk_print_operation_set_print_settings((GtkPrintOperation*)({* id *}), (GtkPrintSettings*)({* property.value *}))"} },
    show_progress      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_show_progress((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    status             = {__type__="GtkPrintStatus"    ,__default__ = "GTK_PRINT_STATUS_INITIAL"  },
    status_string      = {__type__="gchar*"            ,__default__ = "\"\""                      },
    support_selection  = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_support_selection((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    track_print_status = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_track_print_status((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    unit               = {__type__="GtkUnit"           ,__default__ = "GTK_UNIT_PIXEL"           , __gencode__ = {"gtk_print_operation_set_unit((GtkPrintOperation*)({* id *}), (GtkUnit)({* property.value *}))"} },
    use_full_page      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_use_full_page((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk224.GtkPrintOperationPreview}, 
};

---------------------  GtkPrintSettings
Gtk224.GtkPrintSettings = {
  class = "GtkPrintSettings", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_print_settings_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_print_settings_new_from_file((const gchar*)({* this.file_name.value *}))", 
            params = { type = {}, name = {} } },
    new_from_key_file = { gencode = "gtk_print_settings_new_from_key_file((GKeyFile*)({* this.key_file.value *}), (const gchar*)({* this.group_name.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkRcStyle
Gtk224.GtkRcStyle = {
  class = "GtkRcStyle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_rc_style_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    create_rc_style = {"GtkRcStyle*", {"GtkRcStyle*"}, {"rc_style"} }, 
    create_style    = {"GtkStyle*"  , {"GtkRcStyle*"}, {"rc_style"} }, 
    merge           = {"void"       , {"GtkRcStyle*", "GtkRcStyle*"}, {"dest", "src"} }, 
    parse           = {"guint"      , {"GtkRcStyle*", "GtkSettings*", "GScanner*"}, {"rc_style", "settings", "scanner"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkRecentManager
Gtk224.GtkRecentManager = {
  class = "GtkRecentManager", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_recent_manager_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkRecentManager*"}, {"manager"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkRecentManager*"}, name ={"manager"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filename = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
    limit    = {__type__="gint"   ,__default__ = "-1"   , __gencode__ = {"gtk_recent_manager_set_limit((GtkRecentManager*)({* id *}), (gint)({* property.value *}))"} },
    size     = {__type__="gint"   ,__default__ = "0"     },
  },
  parent = nil, 
};

---------------------  GtkSettings
Gtk224.GtkSettings = {
  class = "GtkSettings", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    color_hash                       = {__type__="GHashTable*"                                                                                                                                                                                  },
    gtk_alternative_button_order     = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    gtk_alternative_sort_arrows      = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    gtk_auto_mnemonics               = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    gtk_button_images                = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_can_change_accels            = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    gtk_color_palette                = {__type__="gchar*"            ,__default__ = "\"black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90\"" ,rwflags="rw" },
    gtk_color_scheme                 = {__type__="gchar*"            ,__default__ = "\"\""                                                                                                                                                     ,rwflags="rw" },
    gtk_cursor_blink                 = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_cursor_blink_time            = {__type__="gint"              ,__default__ = "1200"                                                                                                                                                     ,rwflags="rw" },
    gtk_cursor_blink_timeout         = {__type__="gint"              ,__default__ = "2147483647"                                                                                                                                               ,rwflags="rw" },
    gtk_cursor_theme_name            = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_cursor_theme_size            = {__type__="gint"              ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    gtk_dnd_drag_threshold           = {__type__="gint"              ,__default__ = "8"                                                                                                                                                        ,rwflags="rw" },
    gtk_double_click_distance        = {__type__="gint"              ,__default__ = "5"                                                                                                                                                        ,rwflags="rw" },
    gtk_double_click_time            = {__type__="gint"              ,__default__ = "250"                                                                                                                                                      ,rwflags="rw" },
    gtk_enable_accels                = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_enable_animations            = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_enable_event_sounds          = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_enable_input_feedback_sounds = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_enable_mnemonics             = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_enable_tooltips              = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_entry_password_hint_timeout  = {__type__="guint"             ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    gtk_entry_select_on_focus        = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_error_bell                   = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_fallback_icon_theme          = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_file_chooser_backend         = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_font_name                    = {__type__="gchar*"            ,__default__ = "\"Sans 10\""                                                                                                                                              ,rwflags="rw" },
    gtk_fontconfig_timestamp         = {__type__="guint"             ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    gtk_icon_sizes                   = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_icon_theme_name              = {__type__="gchar*"            ,__default__ = "\"hicolor\""                                                                                                                                              ,rwflags="rw" },
    gtk_im_module                    = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_im_preedit_style             = {__type__="GtkIMPreeditStyle" ,__default__ = "GTK_IM_PREEDIT_CALLBACK"                                                                                                                                  ,rwflags="rw" },
    gtk_im_status_style              = {__type__="GtkIMStatusStyle"  ,__default__ = "GTK_IM_STATUS_CALLBACK"                                                                                                                                   ,rwflags="rw" },
    gtk_key_theme_name               = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_keynav_cursor_only           = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    gtk_keynav_wrap_around           = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_label_select_on_focus        = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_menu_bar_accel               = {__type__="gchar*"            ,__default__ = "\"F10\""                                                                                                                                                  ,rwflags="rw" },
    gtk_menu_bar_popup_delay         = {__type__="gint"              ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    gtk_menu_images                  = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_menu_popdown_delay           = {__type__="gint"              ,__default__ = "1000"                                                                                                                                                     ,rwflags="rw" },
    gtk_menu_popup_delay             = {__type__="gint"              ,__default__ = "225"                                                                                                                                                      ,rwflags="rw" },
    gtk_modules                      = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_primary_button_warps_slider  = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    gtk_print_backends               = {__type__="gchar*"            ,__default__ = "\"file,lpr\""                                                                                                                                             ,rwflags="rw" },
    gtk_print_preview_command        = {__type__="gchar*"            ,__default__ = "\"evince --unlink-tempfile --preview --print-settings %s %f\""                                                                                            ,rwflags="rw" },
    gtk_recent_files_limit           = {__type__="gint"              ,__default__ = "50"                                                                                                                                                       ,rwflags="rw" },
    gtk_recent_files_max_age         = {__type__="gint"              ,__default__ = "30"                                                                                                                                                       ,rwflags="rw" },
    gtk_scrolled_window_placement    = {__type__="GtkCornerType"     ,__default__ = "GTK_CORNER_TOP_LEFT"                                                                                                                                      ,rwflags="rw" },
    gtk_show_input_method_menu       = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_show_unicode_menu            = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_sound_theme_name             = {__type__="gchar*"            ,__default__ = "\"freedesktop\""                                                                                                                                          ,rwflags="rw" },
    gtk_split_cursor                 = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    gtk_theme_name                   = {__type__="gchar*"            ,__default__ = "\"Raleigh\""                                                                                                                                              ,rwflags="rw" },
    gtk_timeout_expand               = {__type__="gint"              ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    gtk_timeout_initial              = {__type__="gint"              ,__default__ = "200"                                                                                                                                                      ,rwflags="rw" },
    gtk_timeout_repeat               = {__type__="gint"              ,__default__ = "20"                                                                                                                                                       ,rwflags="rw" },
    gtk_toolbar_icon_size            = {__type__="GtkIconSize"       ,__default__ = "GTK_ICON_SIZE_LARGE_TOOLBAR"                                                                                                                              ,rwflags="rw" },
    gtk_toolbar_style                = {__type__="GtkToolbarStyle"   ,__default__ = "GTK_TOOLBAR_BOTH"                                                                                                                                         ,rwflags="rw" },
    gtk_tooltip_browse_mode_timeout  = {__type__="gint"              ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    gtk_tooltip_browse_timeout       = {__type__="gint"              ,__default__ = "60"                                                                                                                                                       ,rwflags="rw" },
    gtk_tooltip_timeout              = {__type__="gint"              ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    gtk_touchscreen_mode             = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    gtk_xft_antialias                = {__type__="gint"              ,__default__ = "-1"                                                                                                                                                       ,rwflags="rw" },
    gtk_xft_dpi                      = {__type__="gint"              ,__default__ = "-1"                                                                                                                                                       ,rwflags="rw" },
    gtk_xft_hinting                  = {__type__="gint"              ,__default__ = "-1"                                                                                                                                                       ,rwflags="rw" },
    gtk_xft_hintstyle                = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    gtk_xft_rgba                     = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkSizeGroup
Gtk224.GtkSizeGroup = {
  class = "GtkSizeGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_size_group_new((GtkSizeGroupMode)({* this.mode.value *}))", 
            params = { type = {"GtkSizeGroupMode"}, 
                       name = {"mode"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ignore_hidden = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_size_group_set_ignore_hidden((GtkSizeGroup*)({* id *}), (gboolean)({* property.value *}))"} },
    mode          = {__type__="GtkSizeGroupMode" ,__default__ = "GTK_SIZE_GROUP_HORIZONTAL" , __gencode__ = {"gtk_size_group_set_mode((GtkSizeGroup*)({* id *}), (GtkSizeGroupMode)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkStatusIcon
Gtk224.GtkStatusIcon = {
  class = "GtkStatusIcon", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_status_icon_new()", 
            params = { type = {}, name = {} } },
    new_from_file      = { gencode = "gtk_status_icon_new_from_file((const gchar*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gicon     = { gencode = "gtk_status_icon_new_from_gicon((GIcon*)({* this.icon.value *}))", 
            params = { type = {}, name = {} } },
    new_from_icon_name = { gencode = "gtk_status_icon_new_from_icon_name((const gchar*)({* this.icon_name.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"icon_name"} } },
    new_from_pixbuf    = { gencode = "gtk_status_icon_new_from_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {"GdkPixbuf*"}, 
                       name = {"pixbuf"} } },
    new_from_stock     = { gencode = "gtk_status_icon_new_from_stock((const gchar*)({* this.stock_id.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate             = {"void"    , {"GtkStatusIcon*"}, {"status_icon"} }, 
    button_press_event   = {"gboolean", {"GtkStatusIcon*", "GdkEventButton*"}, {"status_icon", "event"} }, 
    button_release_event = {"gboolean", {"GtkStatusIcon*", "GdkEventButton*"}, {"status_icon", "event"} }, 
    popup_menu           = {"void"    , {"GtkStatusIcon*", "guint", "guint32"}, {"status_icon", "button", "activate_time"} }, 
    query_tooltip        = {"gboolean", {"GtkStatusIcon*", "gint", "gint", "gboolean", "GtkTooltip*"}, {"status_icon", "x", "y", "keyboard_mode", "tooltip"} }, 
    scroll_event         = {"gboolean", {"GtkStatusIcon*", "GdkEventScroll*"}, {"status_icon", "event"} }, 
    size_changed         = {"gboolean", {"GtkStatusIcon*", "gint"}, {"status_icon", "size"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate                 = {ret_type = "void"    , params = {type = {"GtkStatusIcon*"}, name ={"status_icon"}} }, 
    ['button-press-event']   = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "GdkEvent*"}, name ={"statusicon", "event"}} }, 
    ['button-release-event'] = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "GdkEvent*"}, name ={"statusicon", "event"}} }, 
    ['popup-menu']           = {ret_type = "void"    , params = {type = {"GtkStatusIcon*", "guint", "guint"}, name ={"statusicon", "button", "activate_time"}} }, 
    ['query-tooltip']        = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "gint", "gint", "gboolean", "GtkTooltip*"}, name ={"statusicon", "x", "y", "keyboard_mode", "tooltip"}} }, 
    ['scroll-event']         = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "GdkEvent*"}, name ={"statusicon", "event"}} }, 
    ['size-changed']         = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "gint"}, name ={"statusicon", "size"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    blinking       = {__type__="gboolean"       ,__default__ = "FALSE"                      , __gencode__ = {"gtk_status_icon_set_blinking((GtkStatusIcon*)({* id *}), (gboolean)({* property.value *}))"} },
    embedded       = {__type__="gboolean"       ,__default__ = "FALSE"                       },
    file           = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_from_file((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    gicon          = {__type__="GIcon*"                                                     , __gencode__ = {"gtk_status_icon_set_from_gicon((GtkStatusIcon*)({* id *}), (GIcon*)({* property.value *}))"} },
    has_tooltip    = {__type__="gboolean"       ,__default__ = "FALSE"                      , __gencode__ = {"gtk_status_icon_set_has_tooltip((GtkStatusIcon*)({* id *}), (gboolean)({* property.value *}))"} },
    icon_name      = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_from_icon_name((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    orientation    = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_HORIZONTAL"  },
    pixbuf         = {__type__="GdkPixbuf*"                                                 , __gencode__ = {"gtk_status_icon_set_from_pixbuf((GtkStatusIcon*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    screen         = {__type__="GdkScreen*"                                                 , __gencode__ = {"gtk_status_icon_set_screen((GtkStatusIcon*)({* id *}), (GdkScreen*)({* property.value *}))"} },
    size           = {__type__="gint"           ,__default__ = "0"                           },
    stock          = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_from_stock((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    storage_type   = {__type__="GtkImageType"   ,__default__ = "GTK_IMAGE_EMPTY"             },
    title          = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_title((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    tooltip_markup = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_tooltip_markup((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    tooltip_text   = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_tooltip_text((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    visible        = {__type__="gboolean"       ,__default__ = "TRUE"                       , __gencode__ = {"gtk_status_icon_set_visible((GtkStatusIcon*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkStyle
Gtk224.GtkStyle = {
  class = "GtkStyle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_style_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    clone            = {"GtkStyle*" , {"GtkStyle*"}, {"style"} }, 
    copy             = {"void"      , {"GtkStyle*", "GtkStyle*"}, {"style", "src"} }, 
    draw_arrow       = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "GtkArrowType", "gboolean", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "arrow_type", "fill", "x", "y", "width", "height"} }, 
    draw_box         = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_box_gap     = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkPositionType", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height", "gap_side", "gap_x", "gap_width"} }, 
    draw_check       = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_diamond     = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_expander    = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "GtkExpanderStyle"}, {"style", "window", "state_type", "area", "widget", "detail", "x", "y", "expander_style"} }, 
    draw_extension   = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkPositionType"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height", "gap_side"} }, 
    draw_flat_box    = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_focus       = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_handle      = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkOrientation"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height", "orientation"} }, 
    draw_hline       = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint"}, {"style", "window", "state_type", "area", "widget", "detail", "x1", "x2", "y"} }, 
    draw_layout      = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "gboolean", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "PangoLayout*"}, {"style", "window", "state_type", "use_text", "area", "widget", "detail", "x", "y", "layout"} }, 
    draw_option      = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_polygon     = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "GdkPoint*", "gint", "gboolean"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "point", "npoints", "fill"} }, 
    draw_resize_grip = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GdkRectangle*", "GtkWidget*", "const gchar*", "GdkWindowEdge", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "area", "widget", "detail", "edge", "x", "y", "width", "height"} }, 
    draw_shadow      = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_shadow_gap  = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkPositionType", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height", "gap_side", "gap_x", "gap_width"} }, 
    draw_slider      = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkOrientation"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height", "orientation"} }, 
    draw_spinner     = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GdkRectangle*", "GtkWidget*", "const gchar*", "guint", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "area", "widget", "detail", "step", "x", "y", "width", "height"} }, 
    draw_string      = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "const gchar*"}, {"style", "window", "state_type", "area", "widget", "detail", "x", "y", "string"} }, 
    draw_tab         = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GtkShadowType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "window", "state_type", "shadow_type", "area", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_vline       = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType", "GdkRectangle*", "GtkWidget*", "const gchar*", "gint", "gint", "gint"}, {"style", "window", "state_type", "area", "widget", "detail", "y1_", "y2_", "x"} }, 
    init_from_rc     = {"void"      , {"GtkStyle*", "GtkRcStyle*"}, {"style", "rc_style"} }, 
    realize          = {"void"      , {"GtkStyle*"}, {"style"} }, 
    render_icon      = {"GdkPixbuf*", {"GtkStyle*", "const GtkIconSource*", "GtkTextDirection", "GtkStateType", "GtkIconSize", "GtkWidget*", "const gchar*"}, {"style", "source", "direction", "state", "size", "widget", "detail"} }, 
    set_background   = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType"}, {"style", "window", "state_type"} }, 
    unrealize        = {"void"      , {"GtkStyle*"}, {"style"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    realize   = {ret_type = "void", params = {type = {"GtkStyle*"}, name ={"style"}} }, 
    unrealize = {ret_type = "void", params = {type = {"GtkStyle*"}, name ={"style"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTextBuffer
Gtk224.GtkTextBuffer = {
  class = "GtkTextBuffer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_buffer_new((GtkTextTagTable*)({* this.table.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    apply_tag           = {"void", {"GtkTextBuffer*", "GtkTextTag*", "const GtkTextIter*", "const GtkTextIter*"}, {"buffer", "tag", "start_char", "end_char"} }, 
    begin_user_action   = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    changed             = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    delete_range        = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GtkTextIter*"}, {"buffer", "start", "end"} }, 
    end_user_action     = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    insert_child_anchor = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GtkTextChildAnchor*"}, {"buffer", "pos", "anchor"} }, 
    insert_pixbuf       = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GdkPixbuf*"}, {"buffer", "pos", "pixbuf"} }, 
    insert_text         = {"void", {"GtkTextBuffer*", "GtkTextIter*", "const gchar*", "gint"}, {"buffer", "pos", "text", "length"} }, 
    mark_deleted        = {"void", {"GtkTextBuffer*", "GtkTextMark*"}, {"buffer", "mark"} }, 
    mark_set            = {"void", {"GtkTextBuffer*", "const GtkTextIter*", "GtkTextMark*"}, {"buffer", "location", "mark"} }, 
    modified_changed    = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    paste_done          = {"void", {"GtkTextBuffer*", "GtkClipboard*"}, {"buffer", "clipboard"} }, 
    remove_tag          = {"void", {"GtkTextBuffer*", "GtkTextTag*", "const GtkTextIter*", "const GtkTextIter*"}, {"buffer", "tag", "start_char", "end_char"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['apply-tag']           = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextTag*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "tag", "start", "end"}} }, 
    ['begin-user-action']   = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    changed                 = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"buffer"}} }, 
    ['delete-range']        = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "start", "end"}} }, 
    ['end-user-action']     = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    ['insert-child-anchor'] = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextChildAnchor*"}, name ={"textbuffer", "location", "anchor"}} }, 
    ['insert-pixbuf']       = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GdkPixbuf*"}, name ={"textbuffer", "location", "pixbuf"}} }, 
    ['insert-text']         = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "gchar*", "gint"}, name ={"textbuffer", "location", "text", "len"}} }, 
    ['mark-deleted']        = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextMark*"}, name ={"textbuffer", "mark"}} }, 
    ['mark-set']            = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextMark*"}, name ={"textbuffer", "location", "mark"}} }, 
    ['modified-changed']    = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    ['paste-done']          = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkClipboard*"}, name ={"textbuffer", "object"}} }, 
    ['remove-tag']          = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextTag*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "tag", "start", "end"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    copy_target_list  = {__type__="GtkTargetList*"                           },
    cursor_position   = {__type__="gint"             ,__default__ = "0"      },
    has_selection     = {__type__="gboolean"         ,__default__ = "FALSE"  },
    paste_target_list = {__type__="GtkTargetList*"                           },
    tag_table         = {__type__="GtkTextTagTable*"                        ,rwflags="rw" },
    text              = {__type__="gchar*"           ,__default__ = "\"\""  , __gencode__ = {"gtk_text_buffer_set_text((GtkTextBuffer*)({* id *}), (const gchar*)({* property.value *}), (gint)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkTextChildAnchor
Gtk224.GtkTextChildAnchor = {
  class = "GtkTextChildAnchor", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_child_anchor_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTextLayout
Gtk224.GtkTextLayout = {
  class = "GtkTextLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_layout_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    allocate_child     = {"void"            , {"GtkTextLayout*", "GtkWidget*", "gint", "gint"}, {"layout", "child", "x", "y"} }, 
    changed            = {"void"            , {"GtkTextLayout*", "gint", "gint", "gint"}, {"layout", "y", "old_height", "new_height"} }, 
    free_line_data     = {"void"            , {"GtkTextLayout*", "GtkTextLine*", "GtkTextLineData*"}, {"layout", "line", "line_data"} }, 
    get_log_attrs      = {"void"            , {"GtkTextLayout*", "GtkTextLine*", "PangoLogAttr**", "gint*"}, {"layout", "line", "attrs", "n_attrs"} }, 
    invalidate         = {"void"            , {"GtkTextLayout*", "const GtkTextIter*", "const GtkTextIter*"}, {"layout", "start", "end"} }, 
    invalidate_cursors = {"void"            , {"GtkTextLayout*", "const GtkTextIter*", "const GtkTextIter*"}, {"layout", "start", "end"} }, 
    invalidated        = {"void"            , {"GtkTextLayout*"}, {"layout"} }, 
    wrap               = {"GtkTextLineData*", {"GtkTextLayout*", "GtkTextLine*", "GtkTextLineData*"}, {"layout", "line", "line_data"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['allocate-child'] = {ret_type = "void", params = {type = {"GtkTextLayout*", "GtkObject*", "gint", "gint"}, name ={"textlayout", "object", "p0", "p1"}} }, 
    changed            = {ret_type = "void", params = {type = {"GtkTextLayout*", "gint", "gint", "gint"}, name ={"layout", "y", "old_height", "new_height"}} }, 
    invalidated        = {ret_type = "void", params = {type = {"GtkTextLayout*"}, name ={"layout"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTextMark
Gtk224.GtkTextMark = {
  class = "GtkTextMark", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_mark_new((const gchar*)({* this.name.value *}), (gboolean)({* this.left_gravity.value *}))", 
            params = { type = {"const gchar*", "gboolean"}, 
                       name = {"name", "left_gravity"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    left_gravity = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    name         = {__type__="gchar*"   ,__default__ = "NULL"  ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTextTag
Gtk224.GtkTextTag = {
  class = "GtkTextTag", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_tag_new((const gchar*)({* this.name.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"name"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    event = {"gboolean", {"GtkTextTag*", "GObject*", "GdkEvent*", "const GtkTextIter*"}, {"tag", "event_object", "event", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    event = {ret_type = "gboolean", params = {type = {"GtkTextTag*", "GObject*", "GdkEvent*", "const GtkTextIter*"}, name ={"tag", "event_object", "event", "iter"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accumulative_margin        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    background                 = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    background_full_height     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    background_full_height_set = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    background_gdk             = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    background_set             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    background_stipple         = {__type__="GdkPixmap*"                                                  ,rwflags="rw" },
    background_stipple_set     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    direction                  = {__type__="GtkTextDirection"      ,__default__ = "GTK_TEXT_DIR_NONE"    ,rwflags="rw" },
    editable                   = {__type__="gboolean"              ,__default__ = "TRUE"                 ,rwflags="rw" },
    editable_set               = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    family                     = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    family_set                 = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    font                       = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    font_desc                  = {__type__="PangoFontDescription*"                                       ,rwflags="rw" },
    foreground                 = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    foreground_gdk             = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    foreground_set             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    foreground_stipple         = {__type__="GdkPixmap*"                                                  ,rwflags="rw" },
    foreground_stipple_set     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    indent                     = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    indent_set                 = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    invisible                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    invisible_set              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    justification              = {__type__="GtkJustification"      ,__default__ = "GTK_JUSTIFY_LEFT"     ,rwflags="rw" },
    justification_set          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    language                   = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    language_set               = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    left_margin                = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    left_margin_set            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    name                       = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    paragraph_background       = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    paragraph_background_gdk   = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    paragraph_background_set   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    pixels_above_lines         = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    pixels_above_lines_set     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    pixels_below_lines         = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    pixels_below_lines_set     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    pixels_inside_wrap         = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    pixels_inside_wrap_set     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    right_margin               = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    right_margin_set           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    rise                       = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    rise_set                   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    scale                      = {__type__="gdouble"               ,__default__ = "1"                    ,rwflags="rw" },
    scale_set                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    size                       = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    size_points                = {__type__="gdouble"               ,__default__ = "0"                    ,rwflags="rw" },
    size_set                   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    stretch                    = {__type__="PangoStretch"          ,__default__ = "PANGO_STRETCH_NORMAL" ,rwflags="rw" },
    stretch_set                = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    strikethrough              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    strikethrough_set          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    style                      = {__type__="PangoStyle"            ,__default__ = "PANGO_STYLE_NORMAL"   ,rwflags="rw" },
    style_set                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    tabs                       = {__type__="PangoTabArray*"                                              ,rwflags="rw" },
    tabs_set                   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    underline                  = {__type__="PangoUnderline"        ,__default__ = "PANGO_UNDERLINE_NONE" ,rwflags="rw" },
    underline_set              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    variant                    = {__type__="PangoVariant"          ,__default__ = "PANGO_VARIANT_NORMAL" ,rwflags="rw" },
    variant_set                = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    weight                     = {__type__="gint"                  ,__default__ = "400"                  ,rwflags="rw" },
    weight_set                 = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    wrap_mode                  = {__type__="GtkWrapMode"           ,__default__ = "GTK_WRAP_NONE"        ,rwflags="rw" },
    wrap_mode_set              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTextTagTable
Gtk224.GtkTextTagTable = {
  class = "GtkTextTagTable", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_tag_table_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    tag_added   = {"void", {"GtkTextTagTable*", "GtkTextTag*"}, {"table", "tag"} }, 
    tag_changed = {"void", {"GtkTextTagTable*", "GtkTextTag*", "gboolean"}, {"table", "tag", "size_changed"} }, 
    tag_removed = {"void", {"GtkTextTagTable*", "GtkTextTag*"}, {"table", "tag"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['tag-added']   = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*"}, name ={"texttagtable", "object"}} }, 
    ['tag-changed'] = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*", "gboolean"}, name ={"texttagtable", "object", "p0"}} }, 
    ['tag-removed'] = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*"}, name ={"texttagtable", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkTooltip
Gtk224.GtkTooltip = {
  class = "GtkTooltip", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeModelFilter
Gtk224.GtkTreeModelFilter = {
  class = "GtkTreeModelFilter", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child_model  = {__type__="GtkTreeModel*" ,rwflags="rw" },
    virtual_root = {__type__="GtkTreePath*"  ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk224.GtkTreeDragSource, Gtk224.GtkTreeModel}, 
};

---------------------  GtkTreeModelSort
Gtk224.GtkTreeModelSort = {
  class = "GtkTreeModelSort", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    model = {__type__="GtkTreeModel*" ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk224.GtkTreeDragSource, Gtk224.GtkTreeModel, Gtk224.GtkTreeSortable}, 
};

---------------------  GtkTreeSelection
Gtk224.GtkTreeSelection = {
  class = "GtkTreeSelection", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkTreeSelection*"}, {"selection"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkTreeSelection*"}, name ={"selection"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeStore
Gtk224.GtkTreeStore = {
  class = "GtkTreeStore", 
  constructor = { 
    -- 名称[- ==> _], 
    new  = { gencode = "gtk_tree_store_new((gint)({* this.n_columns.value *}), 0)", 
            params = { type = {}, name = {} } },
    newv = { gencode = "gtk_tree_store_newv((gint)({* this.n_columns.value *}), (GType*)({* this.types.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable, Gtk224.GtkTreeDragDest, Gtk224.GtkTreeDragSource, Gtk224.GtkTreeModel, Gtk224.GtkTreeSortable}, 
};

---------------------  GtkUIManager
Gtk224.GtkUIManager = {
  class = "GtkUIManager", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_ui_manager_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    actions_changed  = {"void"      , {"GtkUIManager*"}, {"merge"} }, 
    add_widget       = {"void"      , {"GtkUIManager*", "GtkWidget*"}, {"merge", "widget"} }, 
    connect_proxy    = {"void"      , {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, {"merge", "action", "proxy"} }, 
    disconnect_proxy = {"void"      , {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, {"merge", "action", "proxy"} }, 
    get_action       = {"GtkAction*", {"GtkUIManager*", "const gchar*"}, {"manager", "path"} }, 
    get_widget       = {"GtkWidget*", {"GtkUIManager*", "const gchar*"}, {"manager", "path"} }, 
    post_activate    = {"void"      , {"GtkUIManager*", "GtkAction*"}, {"merge", "action"} }, 
    pre_activate     = {"void"      , {"GtkUIManager*", "GtkAction*"}, {"merge", "action"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['actions-changed']  = {ret_type = "void", params = {type = {"GtkUIManager*"}, name ={"uimanager"}} }, 
    ['add-widget']       = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkWidget*"}, name ={"uimanager", "widget"}} }, 
    ['connect-proxy']    = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, name ={"uimanager", "action", "proxy"}} }, 
    ['disconnect-proxy'] = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, name ={"uimanager", "action", "proxy"}} }, 
    ['post-activate']    = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*"}, name ={"uimanager", "action"}} }, 
    ['pre-activate']     = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*"}, name ={"uimanager", "action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    add_tearoffs = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_ui_manager_set_add_tearoffs((GtkUIManager*)({* id *}), (gboolean)({* property.value *}))"} },
    ui           = {__type__="gchar*"   ,__default__ = "\""     },
  },
  parent = nil, 
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkWindowGroup
Gtk224.GtkWindowGroup = {
  class = "GtkWindowGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_group_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkAdjustment
Gtk224.GtkAdjustment = {
  class = "GtkAdjustment", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_adjustment_new((gdouble)({* this.value.value *}), (gdouble)({* this.lower.value *}), (gdouble)({* this.upper.value *}), (gdouble)({* this.step_increment.value *}), (gdouble)({* this.page_increment.value *}), (gdouble)({* this.page_size.value *}))", 
            params = { type = {"gdouble", "gdouble", "gdouble", "gdouble", "gdouble", "gdouble"}, 
                       name = {"value", "lower", "upper", "step_increment", "page_increment", "page_size"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed       = {"void", {"GtkAdjustment*"}, {"adjustment"} }, 
    value_changed = {"void", {"GtkAdjustment*"}, {"adjustment"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed           = {ret_type = "void", params = {type = {"GtkAdjustment*"}, name ={"adjustment"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkAdjustment*"}, name ={"adjustment"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    lower          = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_lower((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    page_increment = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_page_increment((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    page_size      = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_page_size((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    step_increment = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_step_increment((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    upper          = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_upper((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    value          = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_value((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
  },
  parent = Gtk224.GtkObject,
};

---------------------  GtkCellRenderer
Gtk224.GtkCellRenderer = {
  class = "GtkCellRenderer", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate         = {"gboolean"        , {"GtkCellRenderer*", "GdkEvent*", "GtkWidget*", "const gchar*", "GdkRectangle*", "GdkRectangle*", "GtkCellRendererState"}, {"cell", "event", "widget", "path", "background_area", "cell_area", "flags"} }, 
    editing_canceled = {"void"            , {"GtkCellRenderer*"}, {"cell"} }, 
    editing_started  = {"void"            , {"GtkCellRenderer*", "GtkCellEditable*", "const gchar*"}, {"cell", "editable", "path"} }, 
    get_size         = {"void"            , {"GtkCellRenderer*", "GtkWidget*", "GdkRectangle*", "gint*", "gint*", "gint*", "gint*"}, {"cell", "widget", "cell_area", "x_offset", "y_offset", "width", "height"} }, 
    render           = {"void"            , {"GtkCellRenderer*", "GdkDrawable*", "GtkWidget*", "GdkRectangle*", "GdkRectangle*", "GdkRectangle*", "GtkCellRendererState"}, {"cell", "window", "widget", "background_area", "cell_area", "expose_area", "flags"} }, 
    start_editing    = {"GtkCellEditable*", {"GtkCellRenderer*", "GdkEvent*", "GtkWidget*", "const gchar*", "GdkRectangle*", "GdkRectangle*", "GtkCellRendererState"}, {"cell", "event", "widget", "path", "background_area", "cell_area", "flags"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['editing-canceled'] = {ret_type = "void", params = {type = {"GtkCellRenderer*"}, name ={"cellrenderer"}} }, 
    ['editing-started']  = {ret_type = "void", params = {type = {"GtkCellRenderer*", "GtkCellEditable*", "gchar*"}, name ={"cellrenderer", "editable", "path"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    cell_background     = {__type__="gchar*"              ,__default__ = "NULL"                         ,rwflags="w" },
    cell_background_gdk = {__type__="GdkColor*"                                                         ,rwflags="rw" },
    cell_background_set = {__type__="gboolean"            ,__default__ = "FALSE"                        ,rwflags="rw" },
    editing             = {__type__="gboolean"            ,__default__ = "FALSE"                         },
    height              = {__type__="gint"                ,__default__ = "-1"                           ,rwflags="rw" },
    is_expanded         = {__type__="gboolean"            ,__default__ = "FALSE"                        ,rwflags="rw" },
    is_expander         = {__type__="gboolean"            ,__default__ = "FALSE"                        ,rwflags="rw" },
    mode                = {__type__="GtkCellRendererMode" ,__default__ = "GTK_CELL_RENDERER_MODE_INERT" ,rwflags="rw" },
    sensitive           = {__type__="gboolean"            ,__default__ = "TRUE"                         , __gencode__ = {"gtk_cell_renderer_set_sensitive((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    visible             = {__type__="gboolean"            ,__default__ = "TRUE"                         , __gencode__ = {"gtk_cell_renderer_set_visible((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    width               = {__type__="gint"                ,__default__ = "-1"                           ,rwflags="rw" },
    xalign              = {__type__="gfloat"              ,__default__ = "0.5"                          ,rwflags="rw" },
    xpad                = {__type__="guint"               ,__default__ = "0"                            ,rwflags="rw" },
    yalign              = {__type__="gfloat"              ,__default__ = "0.5"                          ,rwflags="rw" },
    ypad                = {__type__="guint"               ,__default__ = "0"                            ,rwflags="rw" },
  },
  parent = Gtk224.GtkObject,
};

---------------------  GtkFileFilter
Gtk224.GtkFileFilter = {
  class = "GtkFileFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_filter_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkObject,
};

---------------------  GtkIMContextSimple
Gtk224.GtkIMContextSimple = {
  class = "GtkIMContextSimple", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_im_context_simple_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkIMContext,
};

---------------------  GtkIMMulticontext
Gtk224.GtkIMMulticontext = {
  class = "GtkIMMulticontext", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_im_multicontext_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkIMContext,
};

---------------------  GtkItemFactory
Gtk224.GtkItemFactory = {
  class = "GtkItemFactory", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_item_factory_new((GType)({* this.container_type.value *}), (const gchar*)({* this.path.value *}), (GtkAccelGroup*)({* this.accel_group.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkObject,
};

---------------------  GtkRecentAction
Gtk224.GtkRecentAction = {
  class = "GtkRecentAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this.stock_id.value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock_id"} } },
    new_for_manager = { gencode = "gtk_recent_action_new_for_manager((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this.stock_id.value *}), (GtkRecentManager*)({* this.manager.value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    show_numbers = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_recent_action_set_show_numbers((GtkRecentAction*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkAction,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkRecentChooser}, 
};

---------------------  GtkRecentFilter
Gtk224.GtkRecentFilter = {
  class = "GtkRecentFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_recent_filter_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkObject,
};

---------------------  GtkToggleAction
Gtk224.GtkToggleAction = {
  class = "GtkToggleAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_toggle_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this.stock_id.value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock_id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkToggleAction*"}, {"action"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkToggleAction*"}, name ={"action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active        = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_action_set_active((GtkToggleAction*)({* id *}), (gboolean)({* property.value *}))"} },
    draw_as_radio = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_action_set_draw_as_radio((GtkToggleAction*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkAction,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkTooltips
Gtk224.GtkTooltips = {
  class = "GtkTooltips", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tooltips_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkObject,
};

---------------------  GtkTreeViewColumn
Gtk224.GtkTreeViewColumn = {
  class = "GtkTreeViewColumn", 
  constructor = { 
    -- 名称[- ==> _], 
    new                 = { gencode = "gtk_tree_view_column_new()", 
            params = { type = {}, name = {} } },
    new_with_attributes = { gencode = "gtk_tree_view_column_new_with_attributes((const gchar*)({* this.title.value *}), (GtkCellRenderer*)({* this.cell.value *}), 0)", 
            params = { type = {"const gchar*"}, 
                       name = {"title"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    clicked = {"void", {"GtkTreeViewColumn*"}, {"tree_column"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    clicked = {ret_type = "void", params = {type = {"GtkTreeViewColumn*"}, name ={"tree_column"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    alignment      = {__type__="gfloat"                  ,__default__ = "0"                              , __gencode__ = {"gtk_tree_view_column_set_alignment((GtkTreeViewColumn*)({* id *}), (gfloat)({* property.value *}))"} },
    clickable      = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_clickable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    expand         = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_expand((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    fixed_width    = {__type__="gint"                    ,__default__ = "1"                              , __gencode__ = {"gtk_tree_view_column_set_fixed_width((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    max_width      = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_max_width((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    min_width      = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_min_width((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    reorderable    = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_reorderable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    resizable      = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_resizable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    sizing         = {__type__="GtkTreeViewColumnSizing" ,__default__ = "GTK_TREE_VIEW_COLUMN_GROW_ONLY" , __gencode__ = {"gtk_tree_view_column_set_sizing((GtkTreeViewColumn*)({* id *}), (GtkTreeViewColumnSizing)({* property.value *}))"} },
    sort_column_id = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_sort_column_id((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    sort_indicator = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_sort_indicator((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    sort_order     = {__type__="GtkSortType"             ,__default__ = "GTK_SORT_ASCENDING"             , __gencode__ = {"gtk_tree_view_column_set_sort_order((GtkTreeViewColumn*)({* id *}), (GtkSortType)({* property.value *}))"} },
    spacing        = {__type__="gint"                    ,__default__ = "0"                              , __gencode__ = {"gtk_tree_view_column_set_spacing((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    title          = {__type__="gchar*"                  ,__default__ = "\"\""                           , __gencode__ = {"gtk_tree_view_column_set_title((GtkTreeViewColumn*)({* id *}), (const gchar*)({* property.value *}))"} },
    visible        = {__type__="gboolean"                ,__default__ = "TRUE"                           , __gencode__ = {"gtk_tree_view_column_set_visible((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    widget         = {__type__="GtkWidget*"                                                              , __gencode__ = {"gtk_tree_view_column_set_widget((GtkTreeViewColumn*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    width          = {__type__="gint"                    ,__default__ = "0"                               },
  },
  parent = Gtk224.GtkObject,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellLayout}, 
};

---------------------  GtkWidget
Gtk224.GtkWidget = {
  class = "GtkWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_widget_new((GType)({* this.type.value *}), (const gchar*)({* this.first_property_name.value *}), 0)", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    button_press_event                = {"gboolean"  , {"GtkWidget*", "GdkEventButton*"}, {"widget", "event"} }, 
    button_release_event              = {"gboolean"  , {"GtkWidget*", "GdkEventButton*"}, {"widget", "event"} }, 
    can_activate_accel                = {"gboolean"  , {"GtkWidget*", "guint"}, {"widget", "signal_id"} }, 
    child_notify                      = {"void"      , {"GtkWidget*", "GParamSpec*"}, {"widget", "pspec"} }, 
    client_event                      = {"gboolean"  , {"GtkWidget*", "GdkEventClient*"}, {"widget", "event"} }, 
    composited_changed                = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    configure_event                   = {"gboolean"  , {"GtkWidget*", "GdkEventConfigure*"}, {"widget", "event"} }, 
    delete_event                      = {"gboolean"  , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    destroy_event                     = {"gboolean"  , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    direction_changed                 = {"void"      , {"GtkWidget*", "GtkTextDirection"}, {"widget", "previous_direction"} }, 
    dispatch_child_properties_changed = {"void"      , {"GtkWidget*", "guint", "GParamSpec**"}, {"widget", "n_pspecs", "pspecs"} }, 
    drag_begin                        = {"void"      , {"GtkWidget*", "GdkDragContext*"}, {"widget", "context"} }, 
    drag_data_delete                  = {"void"      , {"GtkWidget*", "GdkDragContext*"}, {"widget", "context"} }, 
    drag_data_get                     = {"void"      , {"GtkWidget*", "GdkDragContext*", "GtkSelectionData*", "guint", "guint"}, {"widget", "context", "selection_data", "info", "time_"} }, 
    drag_data_received                = {"void"      , {"GtkWidget*", "GdkDragContext*", "gint", "gint", "GtkSelectionData*", "guint", "guint"}, {"widget", "context", "x", "y", "selection_data", "info", "time_"} }, 
    drag_drop                         = {"gboolean"  , {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, {"widget", "context", "x", "y", "time_"} }, 
    drag_end                          = {"void"      , {"GtkWidget*", "GdkDragContext*"}, {"widget", "context"} }, 
    drag_leave                        = {"void"      , {"GtkWidget*", "GdkDragContext*", "guint"}, {"widget", "context", "time_"} }, 
    drag_motion                       = {"gboolean"  , {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, {"widget", "context", "x", "y", "time_"} }, 
    enter_notify_event                = {"gboolean"  , {"GtkWidget*", "GdkEventCrossing*"}, {"widget", "event"} }, 
    event                             = {"gboolean"  , {"GtkWidget*", "GdkEvent*"}, {"widget", "event"} }, 
    expose_event                      = {"gboolean"  , {"GtkWidget*", "GdkEventExpose*"}, {"widget", "event"} }, 
    focus                             = {"gboolean"  , {"GtkWidget*", "GtkDirectionType"}, {"widget", "direction"} }, 
    focus_in_event                    = {"gboolean"  , {"GtkWidget*", "GdkEventFocus*"}, {"widget", "event"} }, 
    focus_out_event                   = {"gboolean"  , {"GtkWidget*", "GdkEventFocus*"}, {"widget", "event"} }, 
    get_accessible                    = {"AtkObject*", {"GtkWidget*"}, {"widget"} }, 
    grab_broken_event                 = {"gboolean"  , {"GtkWidget*", "GdkEventGrabBroken*"}, {"widget", "event"} }, 
    grab_focus                        = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    grab_notify                       = {"void"      , {"GtkWidget*", "gboolean"}, {"widget", "was_grabbed"} }, 
    hide                              = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    hide_all                          = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    hierarchy_changed                 = {"void"      , {"GtkWidget*", "GtkWidget*"}, {"widget", "previous_toplevel"} }, 
    key_press_event                   = {"gboolean"  , {"GtkWidget*", "GdkEventKey*"}, {"widget", "event"} }, 
    key_release_event                 = {"gboolean"  , {"GtkWidget*", "GdkEventKey*"}, {"widget", "event"} }, 
    leave_notify_event                = {"gboolean"  , {"GtkWidget*", "GdkEventCrossing*"}, {"widget", "event"} }, 
    map                               = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    map_event                         = {"gboolean"  , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    mnemonic_activate                 = {"gboolean"  , {"GtkWidget*", "gboolean"}, {"widget", "group_cycling"} }, 
    motion_notify_event               = {"gboolean"  , {"GtkWidget*", "GdkEventMotion*"}, {"widget", "event"} }, 
    no_expose_event                   = {"gboolean"  , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    parent_set                        = {"void"      , {"GtkWidget*", "GtkWidget*"}, {"widget", "previous_parent"} }, 
    popup_menu                        = {"gboolean"  , {"GtkWidget*"}, {"widget"} }, 
    property_notify_event             = {"gboolean"  , {"GtkWidget*", "GdkEventProperty*"}, {"widget", "event"} }, 
    proximity_in_event                = {"gboolean"  , {"GtkWidget*", "GdkEventProximity*"}, {"widget", "event"} }, 
    proximity_out_event               = {"gboolean"  , {"GtkWidget*", "GdkEventProximity*"}, {"widget", "event"} }, 
    query_tooltip                     = {"gboolean"  , {"GtkWidget*", "gint", "gint", "gboolean", "GtkTooltip*"}, {"widget", "x", "y", "keyboard_tooltip", "tooltip"} }, 
    realize                           = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    screen_changed                    = {"void"      , {"GtkWidget*", "GdkScreen*"}, {"widget", "previous_screen"} }, 
    scroll_event                      = {"gboolean"  , {"GtkWidget*", "GdkEventScroll*"}, {"widget", "event"} }, 
    selection_clear_event             = {"gboolean"  , {"GtkWidget*", "GdkEventSelection*"}, {"widget", "event"} }, 
    selection_get                     = {"void"      , {"GtkWidget*", "GtkSelectionData*", "guint", "guint"}, {"widget", "selection_data", "info", "time_"} }, 
    selection_notify_event            = {"gboolean"  , {"GtkWidget*", "GdkEventSelection*"}, {"widget", "event"} }, 
    selection_received                = {"void"      , {"GtkWidget*", "GtkSelectionData*", "guint"}, {"widget", "selection_data", "time_"} }, 
    selection_request_event           = {"gboolean"  , {"GtkWidget*", "GdkEventSelection*"}, {"widget", "event"} }, 
    show                              = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    show_all                          = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    show_help                         = {"gboolean"  , {"GtkWidget*", "GtkWidgetHelpType"}, {"widget", "help_type"} }, 
    size_allocate                     = {"void"      , {"GtkWidget*", "GtkAllocation*"}, {"widget", "allocation"} }, 
    size_request                      = {"void"      , {"GtkWidget*", "GtkRequisition*"}, {"widget", "requisition"} }, 
    state_changed                     = {"void"      , {"GtkWidget*", "GtkStateType"}, {"widget", "previous_state"} }, 
    style_set                         = {"void"      , {"GtkWidget*", "GtkStyle*"}, {"widget", "previous_style"} }, 
    unmap                             = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    unmap_event                       = {"gboolean"  , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    unrealize                         = {"void"      , {"GtkWidget*"}, {"widget"} }, 
    visibility_notify_event           = {"gboolean"  , {"GtkWidget*", "GdkEventVisibility*"}, {"widget", "event"} }, 
    window_state_event                = {"gboolean"  , {"GtkWidget*", "GdkEventWindowState*"}, {"widget", "event"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accel-closures-changed']  = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['button-press-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventButton*"}, name ={"widget", "event"}} }, 
    ['button-release-event']    = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventButton*"}, name ={"widget", "event"}} }, 
    ['can-activate-accel']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "guint"}, name ={"widget", "signal_id"}} }, 
    ['child-notify']            = {ret_type = "void"    , params = {type = {"GtkWidget*", "GParamSpec*"}, name ={"widget", "pspec"}} }, 
    ['client-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventClient*"}, name ={"widget", "event"}} }, 
    ['composited-changed']      = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['configure-event']         = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventConfigure*"}, name ={"widget", "event"}} }, 
    ['damage-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['delete-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['destroy-event']           = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['direction-changed']       = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkTextDirection"}, name ={"widget", "previous_direction"}} }, 
    ['drag-begin']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*"}, name ={"widget", "drag_context"}} }, 
    ['drag-data-delete']        = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*"}, name ={"widget", "drag_context"}} }, 
    ['drag-data-get']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*", "GtkSelectionData*", "guint", "guint"}, name ={"widget", "drag_context", "data", "info", "time"}} }, 
    ['drag-data-received']      = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*", "gint", "gint", "GtkSelectionData*", "guint", "guint"}, name ={"widget", "drag_context", "x", "y", "data", "info", "time"}} }, 
    ['drag-drop']               = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, name ={"widget", "drag_context", "x", "y", "time"}} }, 
    ['drag-end']                = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*"}, name ={"widget", "drag_context"}} }, 
    ['drag-failed']             = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkDragContext*", "GtkDragResult"}, name ={"widget", "drag_context", "result"}} }, 
    ['drag-leave']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*", "guint"}, name ={"widget", "drag_context", "time"}} }, 
    ['drag-motion']             = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, name ={"widget", "drag_context", "x", "y", "time"}} }, 
    ['enter-notify-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventCrossing*"}, name ={"widget", "event"}} }, 
    event                       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['event-after']             = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['expose-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventExpose*"}, name ={"widget", "event"}} }, 
    focus                       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    ['focus-in-event']          = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventFocus*"}, name ={"widget", "event"}} }, 
    ['focus-out-event']         = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventFocus*"}, name ={"widget", "event"}} }, 
    ['grab-broken-event']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['grab-focus']              = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['grab-notify']             = {ret_type = "void"    , params = {type = {"GtkWidget*", "gboolean"}, name ={"widget", "was_grabbed"}} }, 
    hide                        = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['hierarchy-changed']       = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkWidget*"}, name ={"widget", "previous_toplevel"}} }, 
    ['key-press-event']         = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventKey*"}, name ={"widget", "event"}} }, 
    ['key-release-event']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventKey*"}, name ={"widget", "event"}} }, 
    ['keynav-failed']           = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    ['leave-notify-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventCrossing*"}, name ={"widget", "event"}} }, 
    map                         = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['map-event']               = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventAny*"}, name ={"widget", "event"}} }, 
    ['mnemonic-activate']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "gboolean"}, name ={"widget", "arg1"}} }, 
    ['motion-notify-event']     = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventMotion*"}, name ={"widget", "event"}} }, 
    ['move-focus']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    ['no-expose-event']         = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventNoExpose*"}, name ={"widget", "event"}} }, 
    ['parent-set']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkWidget*"}, name ={"widget", "old_parent"}} }, 
    ['popup-menu']              = {ret_type = "gboolean", params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['property-notify-event']   = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventProperty*"}, name ={"widget", "event"}} }, 
    ['proximity-in-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventProximity*"}, name ={"widget", "event"}} }, 
    ['proximity-out-event']     = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventProximity*"}, name ={"widget", "event"}} }, 
    ['query-tooltip']           = {ret_type = "gboolean", params = {type = {"GtkWidget*", "gint", "gint", "gboolean", "GtkTooltip*"}, name ={"widget", "x", "y", "keyboard_mode", "tooltip"}} }, 
    realize                     = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['screen-changed']          = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkScreen*"}, name ={"widget", "previous_screen"}} }, 
    ['scroll-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventScroll*"}, name ={"widget", "event"}} }, 
    ['selection-clear-event']   = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventSelection*"}, name ={"widget", "event"}} }, 
    ['selection-get']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkSelectionData*", "guint", "guint"}, name ={"widget", "data", "info", "time"}} }, 
    ['selection-notify-event']  = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['selection-received']      = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkSelectionData*", "guint"}, name ={"widget", "data", "time"}} }, 
    ['selection-request-event'] = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventSelection*"}, name ={"widget", "event"}} }, 
    show                        = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['show-help']               = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GtkWidgetHelpType"}, name ={"widget", "help_type"}} }, 
    ['size-allocate']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkRectangle*"}, name ={"widget", "allocation"}} }, 
    ['size-request']            = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkRequisition*"}, name ={"widget", "requisition"}} }, 
    ['state-changed']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkStateType"}, name ={"widget", "state"}} }, 
    ['style-set']               = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkStyle*"}, name ={"widget", "previous_style"}} }, 
    unmap                       = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['unmap-event']             = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventAny*"}, name ={"widget", "event"}} }, 
    unrealize                   = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['visibility-notify-event'] = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventVisibility*"}, name ={"widget", "event"}} }, 
    ['window-state-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventWindowState*"}, name ={"widget", "event"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    app_paintable    = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_widget_set_app_paintable((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    can_default      = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_widget_set_can_default((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    can_focus        = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_widget_set_can_focus((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    composite_child  = {__type__="gboolean"         ,__default__ = "FALSE"                      },
    double_buffered  = {__type__="gboolean"         ,__default__ = "TRUE"                      , __gencode__ = {"gtk_widget_set_double_buffered((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    events           = {__type__="GdkEventMask"     ,__default__ = "GDK_STRUCTURE_MASK"        , __gencode__ = {"gtk_widget_set_events((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    extension_events = {__type__="GdkExtensionMode" ,__default__ = "GDK_EXTENSION_EVENTS_NONE" , __gencode__ = {"gtk_widget_set_extension_events((GtkWidget*)({* id *}), (GdkExtensionMode)({* property.value *}))"} },
    has_default      = {__type__="gboolean"         ,__default__ = "FALSE"                     ,rwflags="rw" },
    has_focus        = {__type__="gboolean"         ,__default__ = "FALSE"                     ,rwflags="rw" },
    has_tooltip      = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_widget_set_has_tooltip((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    height_request   = {__type__="gint"             ,__default__ = "-1"                        ,rwflags="rw" },
    is_focus         = {__type__="gboolean"         ,__default__ = "FALSE"                     ,rwflags="rw" },
    name             = {__type__="gchar*"           ,__default__ = "NULL"                      , __gencode__ = {"gtk_widget_set_name((GtkWidget*)({* id *}), (const gchar*)({* property.value *}))"} },
    no_show_all      = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_widget_set_no_show_all((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    parent           = {__type__="GtkContainer*"                                               , __gencode__ = {"gtk_widget_set_parent((GtkWidget*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    receives_default = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_widget_set_receives_default((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    sensitive        = {__type__="gboolean"         ,__default__ = "TRUE"                      , __gencode__ = {"gtk_widget_set_sensitive((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    style            = {__type__="GtkStyle*"                                                   , __gencode__ = {"gtk_widget_set_style((GtkWidget*)({* id *}), (GtkStyle*)({* property.value *}))"} },
    tooltip_markup   = {__type__="gchar*"           ,__default__ = "NULL"                      , __gencode__ = {"gtk_widget_set_tooltip_markup((GtkWidget*)({* id *}), (const gchar*)({* property.value *}))"} },
    tooltip_text     = {__type__="gchar*"           ,__default__ = "NULL"                      , __gencode__ = {"gtk_widget_set_tooltip_text((GtkWidget*)({* id *}), (const gchar*)({* property.value *}))"} },
    visible          = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_widget_set_visible((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    width_request    = {__type__="gint"             ,__default__ = "-1"                        ,rwflags="rw" },
    window           = {__type__="GdkWindow*"                                                  , __gencode__ = {"gtk_widget_set_window((GtkWidget*)({* id *}), (GdkWindow*)({* property.value *}))"},rwflags="r" },
  },
  parent = Gtk224.GtkObject,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkCalendar
Gtk224.GtkCalendar = {
  class = "GtkCalendar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_calendar_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    day_selected              = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    day_selected_double_click = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    month_changed             = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    next_month                = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    next_year                 = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    prev_month                = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    prev_year                 = {"void", {"GtkCalendar*"}, {"calendar"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['day-selected']              = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['day-selected-double-click'] = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['month-changed']             = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['next-month']                = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['next-year']                 = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['prev-month']                = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['prev-year']                 = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    day                = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
    detail_height_rows = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_calendar_set_detail_height_rows((GtkCalendar*)({* id *}), (gint)({* property.value *}))"} },
    detail_width_chars = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_calendar_set_detail_width_chars((GtkCalendar*)({* id *}), (gint)({* property.value *}))"} },
    month              = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
    no_month_change    = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    show_day_names     = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    show_details       = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    show_heading       = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    show_week_numbers  = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    year               = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkCellRendererPixbuf
Gtk224.GtkCellRendererPixbuf = {
  class = "GtkCellRendererPixbuf", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_pixbuf_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    follow_state           = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
    gicon                  = {__type__="GIcon*"                            ,rwflags="rw" },
    icon_name              = {__type__="gchar*"     ,__default__ = "NULL"  ,rwflags="rw" },
    pixbuf                 = {__type__="GdkPixbuf*"                        ,rwflags="rw" },
    pixbuf_expander_closed = {__type__="GdkPixbuf*"                        ,rwflags="rw" },
    pixbuf_expander_open   = {__type__="GdkPixbuf*"                        ,rwflags="rw" },
    stock_detail           = {__type__="gchar*"     ,__default__ = "NULL"  ,rwflags="rw" },
    stock_id               = {__type__="gchar*"     ,__default__ = "NULL"  ,rwflags="rw" },
    stock_size             = {__type__="guint"      ,__default__ = "1"     ,rwflags="rw" },
  },
  parent = Gtk224.GtkCellRenderer,
};

---------------------  GtkCellRendererProgress
Gtk224.GtkCellRendererProgress = {
  class = "GtkCellRendererProgress", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_progress_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    orientation = {__type__="GtkProgressBarOrientation" ,__default__ = "GTK_PROGRESS_LEFT_TO_RIGHT" ,rwflags="rw" },
    pulse       = {__type__="gint"                      ,__default__ = "-1"                         ,rwflags="rw" },
    text        = {__type__="gchar*"                    ,__default__ = "NULL"                       ,rwflags="rw" },
    text_xalign = {__type__="gfloat"                    ,__default__ = "0.5"                        ,rwflags="rw" },
    text_yalign = {__type__="gfloat"                    ,__default__ = "0.5"                        ,rwflags="rw" },
    value       = {__type__="gint"                      ,__default__ = "0"                          ,rwflags="rw" },
  },
  parent = Gtk224.GtkCellRenderer,
};

---------------------  GtkCellRendererSpinner
Gtk224.GtkCellRendererSpinner = {
  class = "GtkCellRendererSpinner", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_spinner_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean"    ,__default__ = "FALSE"              ,rwflags="rw" },
    pulse  = {__type__="guint"       ,__default__ = "0"                  ,rwflags="rw" },
    size   = {__type__="GtkIconSize" ,__default__ = "GTK_ICON_SIZE_MENU" ,rwflags="rw" },
  },
  parent = Gtk224.GtkCellRenderer,
};

---------------------  GtkCellRendererText
Gtk224.GtkCellRendererText = {
  class = "GtkCellRendererText", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_text_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    edited = {"void", {"GtkCellRendererText*", "const gchar*", "const gchar*"}, {"cell_renderer_text", "path", "new_text"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    edited = {ret_type = "void", params = {type = {"GtkCellRendererText*", "const gchar*", "const gchar*"}, name ={"cell_renderer_text", "path", "new_text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    align_set             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    alignment             = {__type__="PangoAlignment"        ,__default__ = "PANGO_ALIGN_LEFT"     ,rwflags="rw" },
    attributes            = {__type__="PangoAttrList*"                                              ,rwflags="rw" },
    background            = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    background_gdk        = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    background_set        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    editable              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    editable_set          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ellipsize             = {__type__="PangoEllipsizeMode"    ,__default__ = "PANGO_ELLIPSIZE_NONE" ,rwflags="rw" },
    ellipsize_set         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    family                = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    family_set            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    font                  = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    font_desc             = {__type__="PangoFontDescription*"                                       ,rwflags="rw" },
    foreground            = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    foreground_gdk        = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    foreground_set        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    language              = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    language_set          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    markup                = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    rise                  = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    rise_set              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    scale                 = {__type__="gdouble"               ,__default__ = "1"                    ,rwflags="rw" },
    scale_set             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    single_paragraph_mode = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    size                  = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    size_points           = {__type__="gdouble"               ,__default__ = "0"                    ,rwflags="rw" },
    size_set              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    stretch               = {__type__="PangoStretch"          ,__default__ = "PANGO_STRETCH_NORMAL" ,rwflags="rw" },
    stretch_set           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    strikethrough         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    strikethrough_set     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    style                 = {__type__="PangoStyle"            ,__default__ = "PANGO_STYLE_NORMAL"   ,rwflags="rw" },
    style_set             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    text                  = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    underline             = {__type__="PangoUnderline"        ,__default__ = "PANGO_UNDERLINE_NONE" ,rwflags="rw" },
    underline_set         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    variant               = {__type__="PangoVariant"          ,__default__ = "PANGO_VARIANT_NORMAL" ,rwflags="rw" },
    variant_set           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    weight                = {__type__="gint"                  ,__default__ = "400"                  ,rwflags="rw" },
    weight_set            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    width_chars           = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
    wrap_mode             = {__type__="PangoWrapMode"         ,__default__ = "PANGO_WRAP_CHAR"      ,rwflags="rw" },
    wrap_width            = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
  },
  parent = Gtk224.GtkCellRenderer,
};

---------------------  GtkCellRendererToggle
Gtk224.GtkCellRendererToggle = {
  class = "GtkCellRendererToggle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_toggle_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkCellRendererToggle*", "const gchar*"}, {"cell_renderer_toggle", "path"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkCellRendererToggle*", "const gchar*"}, name ={"cell_renderer_toggle", "path"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activatable    = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_cell_renderer_toggle_set_activatable((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
    active         = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_renderer_toggle_set_active((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
    inconsistent   = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    indicator_size = {__type__="gint"     ,__default__ = "13"    ,rwflags="rw" },
    radio          = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkCellRenderer,
};

---------------------  GtkCellView
Gtk224.GtkCellView = {
  class = "GtkCellView", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_cell_view_new()", 
            params = { type = {}, name = {} } },
    new_with_markup = { gencode = "gtk_cell_view_new_with_markup((const gchar*)({* this.markup.value *}))", 
            params = { type = {}, name = {} } },
    new_with_pixbuf = { gencode = "gtk_cell_view_new_with_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {}, name = {} } },
    new_with_text   = { gencode = "gtk_cell_view_new_with_text((const gchar*)({* this.text.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    background     = {__type__="gchar*"        ,__default__ = "NULL"  ,rwflags="w" },
    background_gdk = {__type__="GdkColor*"                            ,rwflags="rw" },
    background_set = {__type__="gboolean"      ,__default__ = "FALSE" ,rwflags="rw" },
    model          = {__type__="GtkTreeModel*"                        , __gencode__ = {"gtk_cell_view_set_model((GtkCellView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellLayout}, 
};

---------------------  GtkContainer
Gtk224.GtkContainer = {
  class = "GtkContainer", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add                = {"void"  , {"GtkContainer*", "GtkWidget*"}, {"container", "widget"} }, 
    check_resize       = {"void"  , {"GtkContainer*"}, {"container"} }, 
    child_type         = {"GType" , {"GtkContainer*"}, {"container"} }, 
    composite_name     = {"gchar*", {"GtkContainer*", "GtkWidget*"}, {"container", "child"} }, 
    forall             = {"void"  , {"GtkContainer*", "gboolean", "GtkCallback", "gpointer"}, {"container", "include_internals", "callback", "callback_data"} }, 
    get_child_property = {"void"  , {"GtkContainer*", "GtkWidget*", "guint", "GValue*", "GParamSpec*"}, {"container", "child", "property_id", "value", "pspec"} }, 
    remove             = {"void"  , {"GtkContainer*", "GtkWidget*"}, {"container", "widget"} }, 
    set_child_property = {"void"  , {"GtkContainer*", "GtkWidget*", "guint", "const GValue*", "GParamSpec*"}, {"container", "child", "property_id", "value", "pspec"} }, 
    set_focus_child    = {"void"  , {"GtkContainer*", "GtkWidget*"}, {"container", "widget"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    add                 = {ret_type = "void", params = {type = {"GtkContainer*", "GtkWidget*"}, name ={"container", "widget"}} }, 
    ['check-resize']    = {ret_type = "void", params = {type = {"GtkContainer*"}, name ={"container"}} }, 
    remove              = {ret_type = "void", params = {type = {"GtkContainer*", "GtkWidget*"}, name ={"container", "widget"}} }, 
    ['set-focus-child'] = {ret_type = "void", params = {type = {"GtkContainer*", "GtkWidget*"}, name ={"container", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    border_width = {__type__="guint"         ,__default__ = "0"                 , __gencode__ = {"gtk_container_set_border_width((GtkContainer*)({* id *}), (guint)({* property.value *}))"} },
    child        = {__type__="GtkWidget*"                                       ,rwflags="w" },
    resize_mode  = {__type__="GtkResizeMode" ,__default__ = "GTK_RESIZE_PARENT" , __gencode__ = {"gtk_container_set_resize_mode((GtkContainer*)({* id *}), (GtkResizeMode)({* property.value *}))"} },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkDrawingArea
Gtk224.GtkDrawingArea = {
  class = "GtkDrawingArea", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_drawing_area_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkEntry
Gtk224.GtkEntry = {
  class = "GtkEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new                 = { gencode = "gtk_entry_new()", 
            params = { type = {}, name = {} } },
    new_with_buffer     = { gencode = "gtk_entry_new_with_buffer((GtkEntryBuffer*)({* this.buffer.value *}))", 
            params = { type = {"GtkEntryBuffer*"}, 
                       name = {"buffer"} } },
    new_with_max_length = { gencode = "gtk_entry_new_with_max_length((gint)({* this.max.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate           = {"void", {"GtkEntry*"}, {"entry"} }, 
    backspace          = {"void", {"GtkEntry*"}, {"entry"} }, 
    copy_clipboard     = {"void", {"GtkEntry*"}, {"entry"} }, 
    cut_clipboard      = {"void", {"GtkEntry*"}, {"entry"} }, 
    delete_from_cursor = {"void", {"GtkEntry*", "GtkDeleteType", "gint"}, {"entry", "type", "count"} }, 
    get_text_area_size = {"void", {"GtkEntry*", "gint*", "gint*", "gint*", "gint*"}, {"entry", "x", "y", "width", "height"} }, 
    insert_at_cursor   = {"void", {"GtkEntry*", "const gchar*"}, {"entry", "str"} }, 
    move_cursor        = {"void", {"GtkEntry*", "GtkMovementStep", "gint", "gboolean"}, {"entry", "step", "count", "extend_selection"} }, 
    paste_clipboard    = {"void", {"GtkEntry*"}, {"entry"} }, 
    populate_popup     = {"void", {"GtkEntry*", "GtkMenu*"}, {"entry", "menu"} }, 
    toggle_overwrite   = {"void", {"GtkEntry*"}, {"entry"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate               = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    backspace              = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['copy-clipboard']     = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['cut-clipboard']      = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['delete-from-cursor'] = {ret_type = "void", params = {type = {"GtkEntry*", "GtkDeleteType", "gint"}, name ={"entry", "type", "count"}} }, 
    ['icon-press']         = {ret_type = "void", params = {type = {"GtkEntry*", "GtkEntryIconPosition", "GdkEvent*"}, name ={"entry", "icon_pos", "event"}} }, 
    ['icon-release']       = {ret_type = "void", params = {type = {"GtkEntry*", "GtkEntryIconPosition", "GdkEvent*"}, name ={"entry", "icon_pos", "event"}} }, 
    ['insert-at-cursor']   = {ret_type = "void", params = {type = {"GtkEntry*", "gchar*"}, name ={"entry", "string"}} }, 
    ['move-cursor']        = {ret_type = "void", params = {type = {"GtkEntry*", "GtkMovementStep", "gint", "gboolean"}, name ={"entry", "step", "count", "extend_selection"}} }, 
    ['paste-clipboard']    = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['populate-popup']     = {ret_type = "void", params = {type = {"GtkEntry*", "GtkMenu*"}, name ={"entry", "menu"}} }, 
    ['preedit-changed']    = {ret_type = "void", params = {type = {"GtkEntry*", "gchar*"}, name ={"entry", "preedit"}} }, 
    ['toggle-overwrite']   = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activates_default             = {__type__="gboolean"        ,__default__ = "FALSE"           , __gencode__ = {"gtk_entry_set_activates_default((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    buffer                        = {__type__="GtkEntryBuffer*"                                  , __gencode__ = {"gtk_entry_set_buffer((GtkEntry*)({* id *}), (GtkEntryBuffer*)({* property.value *}))"},__construct__= 1 },
    caps_lock_warning             = {__type__="gboolean"        ,__default__ = "TRUE"            ,rwflags="rw" },
    cursor_position               = {__type__="gint"            ,__default__ = "0"                },
    editable                      = {__type__="gboolean"        ,__default__ = "TRUE"            , __gencode__ = {"gtk_entry_set_editable((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    has_frame                     = {__type__="gboolean"        ,__default__ = "TRUE"            , __gencode__ = {"gtk_entry_set_has_frame((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    im_module                     = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    inner_border                  = {__type__="GtkBorder*"                                       , __gencode__ = {"gtk_entry_set_inner_border((GtkEntry*)({* id *}), (const GtkBorder*)({* property.value *}))"} },
    invisible_char                = {__type__="guint"           ,__default__ = "'*'"             , __gencode__ = {"gtk_entry_set_invisible_char((GtkEntry*)({* id *}), (gunichar)({* property.value *}))"} },
    invisible_char_set            = {__type__="gboolean"        ,__default__ = "FALSE"           ,rwflags="rw" },
    max_length                    = {__type__="gint"            ,__default__ = "0"               , __gencode__ = {"gtk_entry_set_max_length((GtkEntry*)({* id *}), (gint)({* property.value *}))"} },
    overwrite_mode                = {__type__="gboolean"        ,__default__ = "FALSE"           , __gencode__ = {"gtk_entry_set_overwrite_mode((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    primary_icon_activatable      = {__type__="gboolean"        ,__default__ = "FALSE"           ,rwflags="rw" },
    primary_icon_gicon            = {__type__="GIcon*"                                           ,rwflags="rw" },
    primary_icon_name             = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    primary_icon_pixbuf           = {__type__="GdkPixbuf*"                                       ,rwflags="rw" },
    primary_icon_sensitive        = {__type__="gboolean"        ,__default__ = "TRUE"            ,rwflags="rw" },
    primary_icon_stock            = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    primary_icon_storage_type     = {__type__="GtkImageType"    ,__default__ = "GTK_IMAGE_EMPTY"  },
    primary_icon_tooltip_markup   = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    primary_icon_tooltip_text     = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    progress_fraction             = {__type__="gdouble"         ,__default__ = "0"               , __gencode__ = {"gtk_entry_set_progress_fraction((GtkEntry*)({* id *}), (gdouble)({* property.value *}))"} },
    progress_pulse_step           = {__type__="gdouble"         ,__default__ = "0.1"             , __gencode__ = {"gtk_entry_set_progress_pulse_step((GtkEntry*)({* id *}), (gdouble)({* property.value *}))"} },
    scroll_offset                 = {__type__="gint"            ,__default__ = "0"                },
    secondary_icon_activatable    = {__type__="gboolean"        ,__default__ = "FALSE"           ,rwflags="rw" },
    secondary_icon_gicon          = {__type__="GIcon*"                                           ,rwflags="rw" },
    secondary_icon_name           = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    secondary_icon_pixbuf         = {__type__="GdkPixbuf*"                                       ,rwflags="rw" },
    secondary_icon_sensitive      = {__type__="gboolean"        ,__default__ = "TRUE"            ,rwflags="rw" },
    secondary_icon_stock          = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    secondary_icon_storage_type   = {__type__="GtkImageType"    ,__default__ = "GTK_IMAGE_EMPTY"  },
    secondary_icon_tooltip_markup = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    secondary_icon_tooltip_text   = {__type__="gchar*"          ,__default__ = "NULL"            ,rwflags="rw" },
    selection_bound               = {__type__="gint"            ,__default__ = "0"                },
    shadow_type                   = {__type__="GtkShadowType"   ,__default__ = "GTK_SHADOW_IN"   ,rwflags="rw" },
    text                          = {__type__="gchar*"          ,__default__ = "\"\""            , __gencode__ = {"gtk_entry_set_text((GtkEntry*)({* id *}), (const gchar*)({* property.value *}))"} },
    text_length                   = {__type__="guint"           ,__default__ = "0"                },
    truncate_multiline            = {__type__="gboolean"        ,__default__ = "FALSE"           ,rwflags="rw" },
    visibility                    = {__type__="gboolean"        ,__default__ = "TRUE"            , __gencode__ = {"gtk_entry_set_visibility((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    width_chars                   = {__type__="gint"            ,__default__ = "-1"              , __gencode__ = {"gtk_entry_set_width_chars((GtkEntry*)({* id *}), (gint)({* property.value *}))"} },
    xalign                        = {__type__="gfloat"          ,__default__ = "0"               ,rwflags="rw" },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellEditable, Gtk224.GtkEditable}, 
};

---------------------  GtkHSV
Gtk224.GtkHSV = {
  class = "GtkHSV", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hsv_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkHSV*"}, {"hsv"} }, 
    move    = {"void", {"GtkHSV*", "GtkDirectionType"}, {"hsv", "type"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkHSV*"}, name ={"hsv"}} }, 
    move    = {ret_type = "void", params = {type = {"GtkHSV*", "GtkDirectionType"}, name ={"hsv", "type"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkInvisible
Gtk224.GtkInvisible = {
  class = "GtkInvisible", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_invisible_new()", 
            params = { type = {}, name = {} } },
    new_for_screen = { gencode = "gtk_invisible_new_for_screen((GdkScreen*)({* this.screen.value *}))", 
            params = { type = {"GdkScreen*"}, 
                       name = {"screen"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    screen = {__type__="GdkScreen*" , __gencode__ = {"gtk_invisible_set_screen((GtkInvisible*)({* id *}), (GdkScreen*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkMisc
Gtk224.GtkMisc = {
  class = "GtkMisc", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    xalign = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    xpad   = {__type__="gint"   ,__default__ = "0"   ,rwflags="rw" },
    yalign = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    ypad   = {__type__="gint"   ,__default__ = "0"   ,rwflags="rw" },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkOldEditable
Gtk224.GtkOldEditable = {
  class = "GtkOldEditable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate        = {"void"  , {"GtkOldEditable*"}, {"editable"} }, 
    copy_clipboard  = {"void"  , {"GtkOldEditable*"}, {"editable"} }, 
    cut_clipboard   = {"void"  , {"GtkOldEditable*"}, {"editable"} }, 
    get_chars       = {"gchar*", {"GtkOldEditable*", "gint", "gint"}, {"editable", "start_pos", "end_pos"} }, 
    kill_char       = {"void"  , {"GtkOldEditable*", "gint"}, {"editable", "direction"} }, 
    kill_line       = {"void"  , {"GtkOldEditable*", "gint"}, {"editable", "direction"} }, 
    kill_word       = {"void"  , {"GtkOldEditable*", "gint"}, {"editable", "direction"} }, 
    move_cursor     = {"void"  , {"GtkOldEditable*", "gint", "gint"}, {"editable", "x", "y"} }, 
    move_page       = {"void"  , {"GtkOldEditable*", "gint", "gint"}, {"editable", "x", "y"} }, 
    move_to_column  = {"void"  , {"GtkOldEditable*", "gint"}, {"editable", "row"} }, 
    move_to_row     = {"void"  , {"GtkOldEditable*", "gint"}, {"editable", "row"} }, 
    move_word       = {"void"  , {"GtkOldEditable*", "gint"}, {"editable", "n"} }, 
    paste_clipboard = {"void"  , {"GtkOldEditable*"}, {"editable"} }, 
    set_editable    = {"void"  , {"GtkOldEditable*", "gboolean"}, {"editable", "is_editable"} }, 
    set_position    = {"void"  , {"GtkOldEditable*", "gint"}, {"editable", "position"} }, 
    set_selection   = {"void"  , {"GtkOldEditable*", "gint", "gint"}, {"editable", "start_pos", "end_pos"} }, 
    update_text     = {"void"  , {"GtkOldEditable*", "gint", "gint"}, {"editable", "start_pos", "end_pos"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate            = {ret_type = "void", params = {type = {"GtkOldEditable*"}, name ={"editable"}} }, 
    ['copy-clipboard']  = {ret_type = "void", params = {type = {"GtkOldEditable*"}, name ={"oldeditable"}} }, 
    ['cut-clipboard']   = {ret_type = "void", params = {type = {"GtkOldEditable*"}, name ={"oldeditable"}} }, 
    ['kill-char']       = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint"}, name ={"oldeditable", "object"}} }, 
    ['kill-line']       = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint"}, name ={"oldeditable", "object"}} }, 
    ['kill-word']       = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint"}, name ={"oldeditable", "object"}} }, 
    ['move-cursor']     = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint", "gint"}, name ={"oldeditable", "object", "p0"}} }, 
    ['move-page']       = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint", "gint"}, name ={"oldeditable", "object", "p0"}} }, 
    ['move-to-column']  = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint"}, name ={"oldeditable", "object"}} }, 
    ['move-to-row']     = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint"}, name ={"oldeditable", "object"}} }, 
    ['move-word']       = {ret_type = "void", params = {type = {"GtkOldEditable*", "gint"}, name ={"oldeditable", "object"}} }, 
    ['paste-clipboard'] = {ret_type = "void", params = {type = {"GtkOldEditable*"}, name ={"oldeditable"}} }, 
    ['set-editable']    = {ret_type = "void", params = {type = {"GtkOldEditable*", "gboolean"}, name ={"oldeditable", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    editable      = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    text_position = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkEditable}, 
};

---------------------  GtkPreview
Gtk224.GtkPreview = {
  class = "GtkPreview", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_preview_new((GtkPreviewType)({* this.type.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    expand = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_preview_set_expand((GtkPreview*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkProgress
Gtk224.GtkProgress = {
  class = "GtkProgress", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    act_mode_enter = {"void", {"GtkProgress*"}, {"progress"} }, 
    paint          = {"void", {"GtkProgress*"}, {"progress"} }, 
    update         = {"void", {"GtkProgress*"}, {"progress"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activity_mode = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_progress_set_activity_mode((GtkProgress*)({* id *}), (gboolean)({* property.value *}))"} },
    show_text     = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_progress_set_show_text((GtkProgress*)({* id *}), (gboolean)({* property.value *}))"} },
    text_xalign   = {__type__="gfloat"   ,__default__ = "0.5"   ,rwflags="rw" },
    text_yalign   = {__type__="gfloat"   ,__default__ = "0.5"   ,rwflags="rw" },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkRadioAction
Gtk224.GtkRadioAction = {
  class = "GtkRadioAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_radio_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this.stock_id.value *}), (gint)({* this.value.value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*", "gint"}, 
                       name = {"name", "label", "tooltip", "stock_id", "value"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkRadioAction*", "GtkRadioAction*"}, {"action", "current"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkRadioAction*", "GtkRadioAction*"}, name ={"action", "current"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    current_value = {__type__="gint"            ,__default__ = "0" , __gencode__ = {"gtk_radio_action_set_current_value((GtkRadioAction*)({* id *}), (gint)({* property.value *}))"} },
    group         = {__type__="GtkRadioAction*"                    , __gencode__ = {"gtk_radio_action_set_group((GtkRadioAction*)({* id *}), (GSList*)({* property.value *}))"} },
    value         = {__type__="gint"            ,__default__ = "0" ,rwflags="rw" },
  },
  parent = Gtk224.GtkToggleAction,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkRange
Gtk224.GtkRange = {
  class = "GtkRange", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    adjust_bounds    = {"void"    , {"GtkRange*", "gdouble"}, {"range", "new_value"} }, 
    change_value     = {"gboolean", {"GtkRange*", "GtkScrollType", "gdouble"}, {"range", "scroll", "new_value"} }, 
    get_range_border = {"void"    , {"GtkRange*", "GtkBorder*"}, {"range", "border_"} }, 
    move_slider      = {"void"    , {"GtkRange*", "GtkScrollType"}, {"range", "scroll"} }, 
    value_changed    = {"void"    , {"GtkRange*"}, {"range"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['adjust-bounds'] = {ret_type = "void"    , params = {type = {"GtkRange*", "gdouble"}, name ={"range", "object"}} }, 
    ['change-value']  = {ret_type = "gboolean", params = {type = {"GtkRange*", "GtkScrollType", "gdouble"}, name ={"range", "scroll", "value"}} }, 
    ['move-slider']   = {ret_type = "void"    , params = {type = {"GtkRange*", "GtkScrollType"}, name ={"range", "step"}} }, 
    ['value-changed'] = {ret_type = "void"    , params = {type = {"GtkRange*"}, name ={"range"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment                = {__type__="GtkAdjustment*"                                            , __gencode__ = {"gtk_range_set_adjustment((GtkRange*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    fill_level                = {__type__="gdouble"            ,__default__ = "1.79769e+308"          , __gencode__ = {"gtk_range_set_fill_level((GtkRange*)({* id *}), (gdouble)({* property.value *}))"} },
    inverted                  = {__type__="gboolean"           ,__default__ = "FALSE"                 , __gencode__ = {"gtk_range_set_inverted((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    lower_stepper_sensitivity = {__type__="GtkSensitivityType" ,__default__ = "GTK_SENSITIVITY_AUTO"  , __gencode__ = {"gtk_range_set_lower_stepper_sensitivity((GtkRange*)({* id *}), (GtkSensitivityType)({* property.value *}))"} },
    restrict_to_fill_level    = {__type__="gboolean"           ,__default__ = "TRUE"                  , __gencode__ = {"gtk_range_set_restrict_to_fill_level((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    round_digits              = {__type__="gint"               ,__default__ = "-1"                    , __gencode__ = {"gtk_range_set_round_digits((GtkRange*)({* id *}), (gint)({* property.value *}))"} },
    show_fill_level           = {__type__="gboolean"           ,__default__ = "FALSE"                 , __gencode__ = {"gtk_range_set_show_fill_level((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    update_policy             = {__type__="GtkUpdateType"      ,__default__ = "GTK_UPDATE_CONTINUOUS" , __gencode__ = {"gtk_range_set_update_policy((GtkRange*)({* id *}), (GtkUpdateType)({* property.value *}))"} },
    upper_stepper_sensitivity = {__type__="GtkSensitivityType" ,__default__ = "GTK_SENSITIVITY_AUTO"  , __gencode__ = {"gtk_range_set_upper_stepper_sensitivity((GtkRange*)({* id *}), (GtkSensitivityType)({* property.value *}))"} },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkRuler
Gtk224.GtkRuler = {
  class = "GtkRuler", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    draw_pos   = {"void", {"GtkRuler*"}, {"ruler"} }, 
    draw_ticks = {"void", {"GtkRuler*"}, {"ruler"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    lower    = {__type__="gdouble"       ,__default__ = "0"          ,rwflags="rw" },
    max_size = {__type__="gdouble"       ,__default__ = "0"          ,rwflags="rw" },
    metric   = {__type__="GtkMetricType" ,__default__ = "GTK_PIXELS" , __gencode__ = {"gtk_ruler_set_metric((GtkRuler*)({* id *}), (GtkMetricType)({* property.value *}))"} },
    position = {__type__="gdouble"       ,__default__ = "0"          ,rwflags="rw" },
    upper    = {__type__="gdouble"       ,__default__ = "0"          ,rwflags="rw" },
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkSeparator
Gtk224.GtkSeparator = {
  class = "GtkSeparator", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkWidget,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkArrow
Gtk224.GtkArrow = {
  class = "GtkArrow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_arrow_new((GtkArrowType)({* this.arrow_type.value *}), (GtkShadowType)({* this.shadow_type.value *}))", 
            params = { type = {"GtkArrowType", "GtkShadowType"}, 
                       name = {"arrow_type", "shadow_type"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    arrow_type  = {__type__="GtkArrowType"  ,__default__ = "GTK_ARROW_RIGHT" ,rwflags="rw" },
    shadow_type = {__type__="GtkShadowType" ,__default__ = "GTK_SHADOW_OUT"  ,rwflags="rw" },
  },
  parent = Gtk224.GtkMisc,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkBin
Gtk224.GtkBin = {
  class = "GtkBin", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkBox
Gtk224.GtkBox = {
  class = "GtkBox", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    homogeneous = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_box_set_homogeneous((GtkBox*)({* id *}), (gboolean)({* property.value *}))"} },
    spacing     = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_box_set_spacing((GtkBox*)({* id *}), (gint)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    expand    = {__type__="gboolean"    ,__default__ = "TRUE" },
    fill      = {__type__="gboolean"    ,__default__ = "TRUE" },
    pack_type = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" },
    padding   = {__type__="guint"       ,__default__ = "0" },
    position  = {__type__="gint"        ,__default__ = "0" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkCList
Gtk224.GtkCList = {
  class = "GtkCList", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_clist_new((gint)({* this.columns.value *}))", 
            params = { type = {}, name = {} } },
    new_with_titles = { gencode = "gtk_clist_new_with_titles((gint)({* this.columns.value *}), (gchar**)({* this.titles.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    abort_column_resize    = {"void"  , {"GtkCList*"}, {"clist"} }, 
    cell_size_request      = {"void"  , {"GtkCList*", "GtkCListRow*", "gint", "GtkRequisition*"}, {"clist", "clist_row", "column", "requisition"} }, 
    clear                  = {"void"  , {"GtkCList*"}, {"clist"} }, 
    click_column           = {"void"  , {"GtkCList*", "gint"}, {"clist", "column"} }, 
    draw_drag_highlight    = {"void"  , {"GtkCList*", "GtkCListRow*", "gint", "GtkCListDragPos"}, {"clist", "target_row", "target_row_number", "drag_pos"} }, 
    draw_row               = {"void"  , {"GtkCList*", "GdkRectangle*", "gint", "GtkCListRow*"}, {"clist", "area", "row", "clist_row"} }, 
    end_selection          = {"void"  , {"GtkCList*"}, {"clist"} }, 
    extend_selection       = {"void"  , {"GtkCList*", "GtkScrollType", "gfloat", "gboolean"}, {"clist", "scroll_type", "position", "auto_start_selection"} }, 
    fake_unselect_all      = {"void"  , {"GtkCList*", "gint"}, {"clist", "row"} }, 
    insert_row             = {"gint"  , {"GtkCList*", "gint", "gchar**"}, {"clist", "row", "text"} }, 
    refresh                = {"void"  , {"GtkCList*"}, {"clist"} }, 
    remove_row             = {"void"  , {"GtkCList*", "gint"}, {"clist", "row"} }, 
    resize_column          = {"void"  , {"GtkCList*", "gint", "gint"}, {"clist", "column", "width"} }, 
    resync_selection       = {"void"  , {"GtkCList*", "GdkEvent*"}, {"clist", "event"} }, 
    row_move               = {"void"  , {"GtkCList*", "gint", "gint"}, {"clist", "source_row", "dest_row"} }, 
    scroll_horizontal      = {"void"  , {"GtkCList*", "GtkScrollType", "gfloat"}, {"clist", "scroll_type", "position"} }, 
    scroll_vertical        = {"void"  , {"GtkCList*", "GtkScrollType", "gfloat"}, {"clist", "scroll_type", "position"} }, 
    select_all             = {"void"  , {"GtkCList*"}, {"clist"} }, 
    select_row             = {"void"  , {"GtkCList*", "gint", "gint", "GdkEvent*"}, {"clist", "row", "column", "event"} }, 
    selection_find         = {"GList*", {"GtkCList*", "gint", "GList*"}, {"clist", "row_number", "row_list_element"} }, 
    set_cell_contents      = {"void"  , {"GtkCList*", "GtkCListRow*", "gint", "GtkCellType", "const gchar*", "guint8", "GdkPixmap*", "GdkBitmap*"}, {"clist", "clist_row", "column", "type", "text", "spacing", "pixmap", "mask"} }, 
    set_scroll_adjustments = {"void"  , {"GtkCList*", "GtkAdjustment*", "GtkAdjustment*"}, {"clist", "hadjustment", "vadjustment"} }, 
    sort_list              = {"void"  , {"GtkCList*"}, {"clist"} }, 
    start_selection        = {"void"  , {"GtkCList*"}, {"clist"} }, 
    toggle_add_mode        = {"void"  , {"GtkCList*"}, {"clist"} }, 
    toggle_focus_row       = {"void"  , {"GtkCList*"}, {"clist"} }, 
    undo_selection         = {"void"  , {"GtkCList*"}, {"clist"} }, 
    unselect_all           = {"void"  , {"GtkCList*"}, {"clist"} }, 
    unselect_row           = {"void"  , {"GtkCList*", "gint", "gint", "GdkEvent*"}, {"clist", "row", "column", "event"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['abort-column-resize']    = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['click-column']           = {ret_type = "void", params = {type = {"GtkCList*", "gint"}, name ={"clist", "object"}} }, 
    ['end-selection']          = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['extend-selection']       = {ret_type = "void", params = {type = {"GtkCList*", "GtkScrollType", "gfloat", "gboolean"}, name ={"clist", "object", "p0", "p1"}} }, 
    ['resize-column']          = {ret_type = "void", params = {type = {"GtkCList*", "gint", "gint"}, name ={"clist", "object", "p0"}} }, 
    ['row-move']               = {ret_type = "void", params = {type = {"GtkCList*", "gint", "gint"}, name ={"clist", "object", "p0"}} }, 
    ['scroll-horizontal']      = {ret_type = "void", params = {type = {"GtkCList*", "GtkScrollType", "gfloat"}, name ={"clist", "object", "p0"}} }, 
    ['scroll-vertical']        = {ret_type = "void", params = {type = {"GtkCList*", "GtkScrollType", "gfloat"}, name ={"clist", "object", "p0"}} }, 
    ['select-all']             = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['select-row']             = {ret_type = "void", params = {type = {"GtkCList*", "gint", "gint", "GdkEvent*"}, name ={"clist", "object", "p0", "p1"}} }, 
    ['set-scroll-adjustments'] = {ret_type = "void", params = {type = {"GtkCList*", "GtkAdjustment*", "GtkAdjustment*"}, name ={"clist", "object", "p0"}} }, 
    ['start-selection']        = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['toggle-add-mode']        = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['toggle-focus-row']       = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['undo-selection']         = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['unselect-all']           = {ret_type = "void", params = {type = {"GtkCList*"}, name ={"clist"}} }, 
    ['unselect-row']           = {ret_type = "void", params = {type = {"GtkCList*", "gint", "gint", "GdkEvent*"}, name ={"clist", "object", "p0", "p1"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    n_columns      = {__type__="guint"            ,__default__ = "0"                  ,rwflags="rw" },
    reorderable    = {__type__="gboolean"         ,__default__ = "FALSE"              , __gencode__ = {"gtk_clist_set_reorderable((GtkCList*)({* id *}), (gboolean)({* property.value *}))"} },
    row_height     = {__type__="guint"            ,__default__ = "0"                  , __gencode__ = {"gtk_clist_set_row_height((GtkCList*)({* id *}), (guint)({* property.value *}))"} },
    selection_mode = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_NONE" , __gencode__ = {"gtk_clist_set_selection_mode((GtkCList*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
    shadow_type    = {__type__="GtkShadowType"    ,__default__ = "GTK_SHADOW_NONE"    , __gencode__ = {"gtk_clist_set_shadow_type((GtkCList*)({* id *}), (GtkShadowType)({* property.value *}))"} },
    sort_type      = {__type__="GtkSortType"      ,__default__ = "GTK_SORT_ASCENDING" , __gencode__ = {"gtk_clist_set_sort_type((GtkCList*)({* id *}), (GtkSortType)({* property.value *}))"} },
    titles_active  = {__type__="gboolean"         ,__default__ = "FALSE"              ,rwflags="rw" },
    use_drag_icons = {__type__="gboolean"         ,__default__ = "FALSE"              , __gencode__ = {"gtk_clist_set_use_drag_icons((GtkCList*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkCellRendererAccel
Gtk224.GtkCellRendererAccel = {
  class = "GtkCellRendererAccel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_accel_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    accel_cleared = {"void", {"GtkCellRendererAccel*", "const gchar*"}, {"accel", "path_string"} }, 
    accel_edited  = {"void", {"GtkCellRendererAccel*", "const gchar*", "guint", "GdkModifierType", "guint"}, {"accel", "path_string", "accel_key", "accel_mods", "hardware_keycode"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accel-cleared'] = {ret_type = "void", params = {type = {"GtkCellRendererAccel*", "gchar*"}, name ={"cellrendereraccel", "path_string"}} }, 
    ['accel-edited']  = {ret_type = "void", params = {type = {"GtkCellRendererAccel*", "gchar*", "guint", "GdkModifierType*", "guint"}, name ={"cellrendereraccel", "path_string", "accel_key", "accel_mods", "hardware_keycode"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accel_key  = {__type__="guint"                    ,__default__ = "0"                                ,rwflags="rw" },
    accel_mode = {__type__="GtkCellRendererAccelMode" ,__default__ = "GTK_CELL_RENDERER_ACCEL_MODE_GTK" ,rwflags="rw" },
    accel_mods = {__type__="GdkModifierType*"                                                           ,rwflags="rw" },
    keycode    = {__type__="guint"                    ,__default__ = "0"                                ,rwflags="rw" },
  },
  parent = Gtk224.GtkCellRendererText,
};

---------------------  GtkCellRendererCombo
Gtk224.GtkCellRendererCombo = {
  class = "GtkCellRendererCombo", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_combo_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkCellRendererCombo*", "gchar*", "GtkTreeIter*"}, name ={"cellrenderercombo", "path_string", "new_iter"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    has_entry   = {__type__="gboolean"      ,__default__ = "TRUE" ,rwflags="rw" },
    model       = {__type__="GtkTreeModel*"                       ,rwflags="rw" },
    text_column = {__type__="gint"          ,__default__ = "-1"   ,rwflags="rw" },
  },
  parent = Gtk224.GtkCellRendererText,
};

---------------------  GtkCellRendererSpin
Gtk224.GtkCellRendererSpin = {
  class = "GtkCellRendererSpin", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_spin_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment = {__type__="GtkAdjustment*"                    ,rwflags="rw" },
    climb_rate = {__type__="gdouble"        ,__default__ = "0" ,rwflags="rw" },
    digits     = {__type__="guint"          ,__default__ = "0" ,rwflags="rw" },
  },
  parent = Gtk224.GtkCellRendererText,
};

---------------------  GtkCurve
Gtk224.GtkCurve = {
  class = "GtkCurve", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_curve_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    curve_type_changed = {"void", {"GtkCurve*"}, {"curve"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['curve-type-changed'] = {ret_type = "void", params = {type = {"GtkCurve*"}, name ={"curve"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    curve_type = {__type__="GtkCurveType" ,__default__ = "GTK_CURVE_TYPE_SPLINE" , __gencode__ = {"gtk_curve_set_curve_type((GtkCurve*)({* id *}), (GtkCurveType)({* property.value *}))"} },
    max_x      = {__type__="gfloat"       ,__default__ = "1"                     ,rwflags="rw" },
    max_y      = {__type__="gfloat"       ,__default__ = "1"                     ,rwflags="rw" },
    min_x      = {__type__="gfloat"       ,__default__ = "0"                     ,rwflags="rw" },
    min_y      = {__type__="gfloat"       ,__default__ = "0"                     ,rwflags="rw" },
  },
  parent = Gtk224.GtkDrawingArea,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkFixed
Gtk224.GtkFixed = {
  class = "GtkFixed", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_fixed_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    x = {__type__="gint" ,__default__ = "0" },
    y = {__type__="gint" ,__default__ = "0" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkHRuler
Gtk224.GtkHRuler = {
  class = "GtkHRuler", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hruler_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkRuler,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkHSeparator
Gtk224.GtkHSeparator = {
  class = "GtkHSeparator", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hseparator_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkSeparator,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkIconView
Gtk224.GtkIconView = {
  class = "GtkIconView", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_icon_view_new()", 
            params = { type = {}, name = {} } },
    new_with_model = { gencode = "gtk_icon_view_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_cursor_item   = {"gboolean", {"GtkIconView*"}, {"icon_view"} }, 
    item_activated         = {"void"    , {"GtkIconView*", "GtkTreePath*"}, {"icon_view", "path"} }, 
    move_cursor            = {"gboolean", {"GtkIconView*", "GtkMovementStep", "gint"}, {"icon_view", "step", "count"} }, 
    select_all             = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    select_cursor_item     = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    selection_changed      = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    set_scroll_adjustments = {"void"    , {"GtkIconView*", "GtkAdjustment*", "GtkAdjustment*"}, {"icon_view", "hadjustment", "vadjustment"} }, 
    toggle_cursor_item     = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    unselect_all           = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-cursor-item']   = {ret_type = "gboolean", params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['item-activated']         = {ret_type = "void"    , params = {type = {"GtkIconView*", "GtkTreePath*"}, name ={"iconview", "path"}} }, 
    ['move-cursor']            = {ret_type = "gboolean", params = {type = {"GtkIconView*", "GtkMovementStep", "gint"}, name ={"iconview", "step", "count"}} }, 
    ['select-all']             = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['select-cursor-item']     = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['selection-changed']      = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['set-scroll-adjustments'] = {ret_type = "void"    , params = {type = {"GtkIconView*", "GtkAdjustment*", "GtkAdjustment*"}, name ={"iconview", "object", "p0"}} }, 
    ['toggle-cursor-item']     = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['unselect-all']           = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    column_spacing   = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_column_spacing((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    columns          = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_columns((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    item_orientation = {__type__="GtkOrientation"   ,__default__ = "GTK_ORIENTATION_VERTICAL" , __gencode__ = {"gtk_icon_view_set_item_orientation((GtkIconView*)({* id *}), (GtkOrientation)({* property.value *}))"} },
    item_padding     = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_item_padding((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    item_width       = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_item_width((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    margin           = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_margin((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    markup_column    = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_markup_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    model            = {__type__="GtkTreeModel*"                                              , __gencode__ = {"gtk_icon_view_set_model((GtkIconView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    orientation      = {__type__="GtkOrientation"   ,__default__ = "GTK_ORIENTATION_VERTICAL" , __gencode__ = {"gtk_icon_view_set_orientation((GtkIconView*)({* id *}), (GtkOrientation)({* property.value *}))"} },
    pixbuf_column    = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_pixbuf_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    reorderable      = {__type__="gboolean"         ,__default__ = "FALSE"                    , __gencode__ = {"gtk_icon_view_set_reorderable((GtkIconView*)({* id *}), (gboolean)({* property.value *}))"} },
    row_spacing      = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_row_spacing((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    selection_mode   = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE"     , __gencode__ = {"gtk_icon_view_set_selection_mode((GtkIconView*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
    spacing          = {__type__="gint"             ,__default__ = "0"                        , __gencode__ = {"gtk_icon_view_set_spacing((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    text_column      = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_text_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    tooltip_column   = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_tooltip_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellLayout}, 
};

---------------------  GtkImage
Gtk224.GtkImage = {
  class = "GtkImage", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_image_new()", 
            params = { type = {}, name = {} } },
    new_from_animation = { gencode = "gtk_image_new_from_animation((GdkPixbufAnimation*)({* this.animation.value *}))", 
            params = { type = {}, name = {} } },
    new_from_file      = { gencode = "gtk_image_new_from_file((const gchar*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gicon     = { gencode = "gtk_image_new_from_gicon((GIcon*)({* this.icon.value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {}, name = {} } },
    new_from_icon_name = { gencode = "gtk_image_new_from_icon_name((const gchar*)({* this.icon_name.value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"icon_name"} } },
    new_from_icon_set  = { gencode = "gtk_image_new_from_icon_set((GtkIconSet*)({* this.icon_set.value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {"GtkIconSet*"}, 
                       name = {"icon_set"} } },
    new_from_image     = { gencode = "gtk_image_new_from_image((GdkImage*)({* this.image.value *}), (GdkBitmap*)({* this.mask.value *}))", 
            params = { type = {"GdkImage*", "GdkBitmap*"}, 
                       name = {"image", "mask"} } },
    new_from_pixbuf    = { gencode = "gtk_image_new_from_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {"GdkPixbuf*"}, 
                       name = {"pixbuf"} } },
    new_from_pixmap    = { gencode = "gtk_image_new_from_pixmap((GdkPixmap*)({* this.pixmap.value *}), (GdkBitmap*)({* this.mask.value *}))", 
            params = { type = {"GdkPixmap*", "GdkBitmap*"}, 
                       name = {"pixmap", "mask"} } },
    new_from_stock     = { gencode = "gtk_image_new_from_stock((const gchar*)({* this.stock_id.value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    file             = {__type__="gchar*"              ,__default__ = "NULL"            , __gencode__ = {"gtk_image_set_from_file((GtkImage*)({* id *}), (const gchar*)({* property.value *}))"} },
    gicon            = {__type__="GIcon*"                                               , __gencode__ = {"gtk_image_set_from_gicon((GtkImage*)({* id *}), (GIcon*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    icon_name        = {__type__="gchar*"              ,__default__ = "NULL"            , __gencode__ = {"gtk_image_set_from_icon_name((GtkImage*)({* id *}), (const gchar*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    icon_set         = {__type__="GtkIconSet*"                                          , __gencode__ = {"gtk_image_set_from_icon_set((GtkImage*)({* id *}), (GtkIconSet*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    icon_size        = {__type__="gint"                ,__default__ = "4"               ,rwflags="rw" },
    image            = {__type__="GdkImage*"                                            , __gencode__ = {"gtk_image_set_from_image((GtkImage*)({* id *}), (GdkImage*)({* property.value *}), (GdkBitmap*)({* property.value *}))"} },
    mask             = {__type__="GdkPixmap*"                                           ,rwflags="rw" },
    pixbuf           = {__type__="GdkPixbuf*"                                           , __gencode__ = {"gtk_image_set_from_pixbuf((GtkImage*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    pixbuf_animation = {__type__="GdkPixbufAnimation*"                                  ,rwflags="rw" },
    pixel_size       = {__type__="gint"                ,__default__ = "-1"              , __gencode__ = {"gtk_image_set_pixel_size((GtkImage*)({* id *}), (gint)({* property.value *}))"} },
    pixmap           = {__type__="GdkPixmap*"                                           , __gencode__ = {"gtk_image_set_from_pixmap((GtkImage*)({* id *}), (GdkPixmap*)({* property.value *}), (GdkBitmap*)({* property.value *}))"} },
    stock            = {__type__="gchar*"              ,__default__ = "NULL"            , __gencode__ = {"gtk_image_set_from_stock((GtkImage*)({* id *}), (const gchar*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    storage_type     = {__type__="GtkImageType"        ,__default__ = "GTK_IMAGE_EMPTY"  },
  },
  parent = Gtk224.GtkMisc,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkLabel
Gtk224.GtkLabel = {
  class = "GtkLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_label_new((const gchar*)({* this.str.value *}))", 
            params = { type = {}, name = {} } },
    new_with_mnemonic = { gencode = "gtk_label_new_with_mnemonic((const gchar*)({* this.str.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_link  = {"gboolean", {"GtkLabel*", "const gchar*"}, {"label", "uri"} }, 
    copy_clipboard = {"void"    , {"GtkLabel*"}, {"label"} }, 
    move_cursor    = {"void"    , {"GtkLabel*", "GtkMovementStep", "gint", "gboolean"}, {"label", "step", "count", "extend_selection"} }, 
    populate_popup = {"void"    , {"GtkLabel*", "GtkMenu*"}, {"label", "menu"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-current-link'] = {ret_type = "void"    , params = {type = {"GtkLabel*"}, name ={"label"}} }, 
    ['activate-link']         = {ret_type = "gboolean", params = {type = {"GtkLabel*", "gchar*"}, name ={"label", "uri"}} }, 
    ['copy-clipboard']        = {ret_type = "void"    , params = {type = {"GtkLabel*"}, name ={"label"}} }, 
    ['move-cursor']           = {ret_type = "void"    , params = {type = {"GtkLabel*", "GtkMovementStep", "gint", "gboolean"}, name ={"label", "step", "count", "extend_selection"}} }, 
    ['populate-popup']        = {ret_type = "void"    , params = {type = {"GtkLabel*", "GtkMenu*"}, name ={"label", "menu"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    angle               = {__type__="gdouble"            ,__default__ = "0"                    , __gencode__ = {"gtk_label_set_angle((GtkLabel*)({* id *}), (gdouble)({* property.value *}))"} },
    attributes          = {__type__="PangoAttrList*"                                           , __gencode__ = {"gtk_label_set_attributes((GtkLabel*)({* id *}), (PangoAttrList*)({* property.value *}))"} },
    cursor_position     = {__type__="gint"               ,__default__ = "0"                     },
    ellipsize           = {__type__="PangoEllipsizeMode" ,__default__ = "PANGO_ELLIPSIZE_NONE" , __gencode__ = {"gtk_label_set_ellipsize((GtkLabel*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    justify             = {__type__="GtkJustification"   ,__default__ = "GTK_JUSTIFY_LEFT"     , __gencode__ = {"gtk_label_set_justify((GtkLabel*)({* id *}), (GtkJustification)({* property.value *}))"} },
    label               = {__type__="gchar*"             ,__default__ = "\"\""                 , __gencode__ = {"gtk_label_set_label((GtkLabel*)({* id *}), (const gchar*)({* property.value *}))"} },
    max_width_chars     = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_label_set_max_width_chars((GtkLabel*)({* id *}), (gint)({* property.value *}))"} },
    mnemonic_keyval     = {__type__="guint"              ,__default__ = "16777215"              },
    mnemonic_widget     = {__type__="GtkWidget*"                                               , __gencode__ = {"gtk_label_set_mnemonic_widget((GtkLabel*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    pattern             = {__type__="gchar*"             ,__default__ = "NULL"                 , __gencode__ = {"gtk_label_set_pattern((GtkLabel*)({* id *}), (const gchar*)({* property.value *}))"} },
    selectable          = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_selectable((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    selection_bound     = {__type__="gint"               ,__default__ = "0"                     },
    single_line_mode    = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_single_line_mode((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    track_visited_links = {__type__="gboolean"           ,__default__ = "TRUE"                 , __gencode__ = {"gtk_label_set_track_visited_links((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    use_markup          = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_use_markup((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    use_underline       = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_use_underline((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    width_chars         = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_label_set_width_chars((GtkLabel*)({* id *}), (gint)({* property.value *}))"} },
    wrap                = {__type__="gboolean"           ,__default__ = "FALSE"                ,rwflags="rw" },
    wrap_mode           = {__type__="PangoWrapMode"      ,__default__ = "PANGO_WRAP_WORD"      ,rwflags="rw" },
  },
  parent = Gtk224.GtkMisc,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkLayout
Gtk224.GtkLayout = {
  class = "GtkLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_layout_new((GtkAdjustment*)({* this.hadjustment.value *}), (GtkAdjustment*)({* this.vadjustment.value *}))", 
            params = { type = {"GtkAdjustment*", "GtkAdjustment*"}, 
                       name = {"hadjustment", "vadjustment"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    set_scroll_adjustments = {"void", {"GtkLayout*", "GtkAdjustment*", "GtkAdjustment*"}, {"layout", "hadjustment", "vadjustment"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['set-scroll-adjustments'] = {ret_type = "void", params = {type = {"GtkLayout*", "GtkAdjustment*", "GtkAdjustment*"}, name ={"layout", "object", "p0"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hadjustment = {__type__="GtkAdjustment*"                      , __gencode__ = {"gtk_layout_set_hadjustment((GtkLayout*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    height      = {__type__="guint"          ,__default__ = "100" ,rwflags="rw" },
    vadjustment = {__type__="GtkAdjustment*"                      , __gencode__ = {"gtk_layout_set_vadjustment((GtkLayout*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    width       = {__type__="guint"          ,__default__ = "100" ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    x = {__type__="gint" ,__default__ = "0" },
    y = {__type__="gint" ,__default__ = "0" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkList
Gtk224.GtkList = {
  class = "GtkList", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_list_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    select_child      = {"void", {"GtkList*", "GtkWidget*"}, {"list", "child"} }, 
    selection_changed = {"void", {"GtkList*"}, {"list"} }, 
    unselect_child    = {"void", {"GtkList*", "GtkWidget*"}, {"list", "child"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['select-child']      = {ret_type = "void", params = {type = {"GtkList*", "GtkWidget*"}, name ={"list", "object"}} }, 
    ['selection-changed'] = {ret_type = "void", params = {type = {"GtkList*"}, name ={"list"}} }, 
    ['unselect-child']    = {ret_type = "void", params = {type = {"GtkList*", "GtkWidget*"}, name ={"list", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    selection_mode = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_NONE" , __gencode__ = {"gtk_list_set_selection_mode((GtkList*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkMenuShell
Gtk224.GtkMenuShell = {
  class = "GtkMenuShell", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_current = {"void"    , {"GtkMenuShell*", "gboolean"}, {"menu_shell", "force_hide"} }, 
    cancel           = {"void"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
    deactivate       = {"void"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
    get_popup_delay  = {"gint"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
    insert           = {"void"    , {"GtkMenuShell*", "GtkWidget*", "gint"}, {"menu_shell", "child", "position"} }, 
    move_current     = {"void"    , {"GtkMenuShell*", "GtkMenuDirectionType"}, {"menu_shell", "direction"} }, 
    move_selected    = {"gboolean", {"GtkMenuShell*", "gint"}, {"menu_shell", "distance"} }, 
    select_item      = {"void"    , {"GtkMenuShell*", "GtkWidget*"}, {"menu_shell", "menu_item"} }, 
    selection_done   = {"void"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-current'] = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "gboolean"}, name ={"menushell", "object"}} }, 
    cancel               = {ret_type = "void"    , params = {type = {"GtkMenuShell*"}, name ={"menu_shell"}} }, 
    ['cycle-focus']      = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "GtkDirectionType"}, name ={"menushell", "object"}} }, 
    deactivate           = {ret_type = "void"    , params = {type = {"GtkMenuShell*"}, name ={"menu_shell"}} }, 
    insert               = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "GtkWidget*", "gint"}, name ={"menu_shell", "child", "position"}} }, 
    ['move-current']     = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "GtkMenuDirectionType"}, name ={"menushell", "object"}} }, 
    ['move-selected']    = {ret_type = "gboolean", params = {type = {"GtkMenuShell*", "gint"}, name ={"menushell", "distance"}} }, 
    ['selection-done']   = {ret_type = "void"    , params = {type = {"GtkMenuShell*"}, name ={"menushell"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    take_focus = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_menu_shell_set_take_focus((GtkMenuShell*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkNotebook
Gtk224.GtkNotebook = {
  class = "GtkNotebook", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_notebook_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    change_current_page = {"gboolean"    , {"GtkNotebook*", "gint"}, {"notebook", "offset"} }, 
    create_window       = {"GtkNotebook*", {"GtkNotebook*", "GtkWidget*", "gint", "gint"}, {"notebook", "page", "x", "y"} }, 
    focus_tab           = {"gboolean"    , {"GtkNotebook*", "GtkNotebookTab"}, {"notebook", "type"} }, 
    insert_page         = {"gint"        , {"GtkNotebook*", "GtkWidget*", "GtkWidget*", "GtkWidget*", "gint"}, {"notebook", "child", "tab_label", "menu_label", "position"} }, 
    move_focus_out      = {"void"        , {"GtkNotebook*", "GtkDirectionType"}, {"notebook", "direction"} }, 
    reorder_tab         = {"gboolean"    , {"GtkNotebook*", "GtkDirectionType", "gboolean"}, {"notebook", "direction", "move_to_last"} }, 
    select_page         = {"gboolean"    , {"GtkNotebook*", "gboolean"}, {"notebook", "move_focus"} }, 
    switch_page         = {"void"        , {"GtkNotebook*", "GtkNotebookPage*", "guint"}, {"notebook", "page", "page_num"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-current-page'] = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "gint"}, name ={"notebook", "object"}} }, 
    ['create-window']       = {ret_type = "{Notebook}", params = {type = {"GtkNotebook*", "GtkWidget*", "gint", "gint"}, name ={"notebook", "page", "x", "y"}} }, 
    ['focus-tab']           = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "GtkNotebookTab"}, name ={"notebook", "object"}} }, 
    ['move-focus-out']      = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkDirectionType"}, name ={"notebook", "object"}} }, 
    ['page-added']          = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['page-removed']        = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['page-reordered']      = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['reorder-tab']         = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "GtkDirectionType", "gboolean"}, name ={"notebook", "object", "p0"}} }, 
    ['select-page']         = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "gboolean"}, name ={"notebook", "object"}} }, 
    ['switch-page']         = {ret_type = "void"      , params = {type = {"GtkNotebook*", "gpointer", "guint"}, name ={"notebook", "object", "p0"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    enable_popup = {__type__="gboolean"        ,__default__ = "FALSE"       ,rwflags="rw" },
    group        = {__type__="gpointer"                                     , __gencode__ = {"gtk_notebook_set_group((GtkNotebook*)({* id *}), (gpointer)({* property.value *}))"} },
    group_id     = {__type__="gint"            ,__default__ = "-1"          , __gencode__ = {"gtk_notebook_set_group_id((GtkNotebook*)({* id *}), (gint)({* property.value *}))"} },
    group_name   = {__type__="gchar*"          ,__default__ = "NULL"        , __gencode__ = {"gtk_notebook_set_group_name((GtkNotebook*)({* id *}), (const gchar*)({* property.value *}))"} },
    homogeneous  = {__type__="gboolean"        ,__default__ = "FALSE"       ,rwflags="rw" },
    page         = {__type__="gint"            ,__default__ = "-1"          ,rwflags="rw" },
    scrollable   = {__type__="gboolean"        ,__default__ = "FALSE"       , __gencode__ = {"gtk_notebook_set_scrollable((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    show_border  = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_notebook_set_show_border((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    show_tabs    = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_notebook_set_show_tabs((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    tab_border   = {__type__="guint"           ,__default__ = "2"           , __gencode__ = {"gtk_notebook_set_tab_border((GtkNotebook*)({* id *}), (guint)({* property.value *}))"} },
    tab_hborder  = {__type__="guint"           ,__default__ = "2"           , __gencode__ = {"gtk_notebook_set_tab_hborder((GtkNotebook*)({* id *}), (guint)({* property.value *}))"} },
    tab_pos      = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP" , __gencode__ = {"gtk_notebook_set_tab_pos((GtkNotebook*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    tab_vborder  = {__type__="guint"           ,__default__ = "2"           , __gencode__ = {"gtk_notebook_set_tab_vborder((GtkNotebook*)({* id *}), (guint)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    detachable  = {__type__="gboolean"    ,__default__ = "FALSE" },
    menu_label  = {__type__="gchar*"      ,__default__ = "NULL" },
    position    = {__type__="gint"        ,__default__ = "0" },
    reorderable = {__type__="gboolean"    ,__default__ = "FALSE" },
    tab_expand  = {__type__="gboolean"    ,__default__ = "FALSE" },
    tab_fill    = {__type__="gboolean"    ,__default__ = "TRUE" },
    tab_label   = {__type__="gchar*"      ,__default__ = "NULL" },
    tab_pack    = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkPaned
Gtk224.GtkPaned = {
  class = "GtkPaned", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    accept_position     = {"gboolean", {"GtkPaned*"}, {"paned"} }, 
    cancel_position     = {"gboolean", {"GtkPaned*"}, {"paned"} }, 
    cycle_child_focus   = {"gboolean", {"GtkPaned*", "gboolean"}, {"paned", "reverse"} }, 
    cycle_handle_focus  = {"gboolean", {"GtkPaned*", "gboolean"}, {"paned", "reverse"} }, 
    move_handle         = {"gboolean", {"GtkPaned*", "GtkScrollType"}, {"paned", "scroll"} }, 
    toggle_handle_focus = {"gboolean", {"GtkPaned*"}, {"paned"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accept-position']     = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
    ['cancel-position']     = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
    ['cycle-child-focus']   = {ret_type = "gboolean", params = {type = {"GtkPaned*", "gboolean"}, name ={"paned", "reversed"}} }, 
    ['cycle-handle-focus']  = {ret_type = "gboolean", params = {type = {"GtkPaned*", "gboolean"}, name ={"paned", "reversed"}} }, 
    ['move-handle']         = {ret_type = "gboolean", params = {type = {"GtkPaned*", "GtkScrollType"}, name ={"paned", "scroll_type"}} }, 
    ['toggle-handle-focus'] = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    max_position = {__type__="gint"     ,__default__ = "2147483647"  },
    min_position = {__type__="gint"     ,__default__ = "0"           },
    position     = {__type__="gint"     ,__default__ = "0"          , __gencode__ = {"gtk_paned_set_position((GtkPaned*)({* id *}), (gint)({* property.value *}))"} },
    position_set = {__type__="gboolean" ,__default__ = "FALSE"      ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    resize = {__type__="gboolean" ,__default__ = "TRUE" },
    shrink = {__type__="gboolean" ,__default__ = "TRUE" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkPixmap
Gtk224.GtkPixmap = {
  class = "GtkPixmap", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_pixmap_new((GdkPixmap*)({* this.pixmap.value *}), (GdkBitmap*)({* this.mask.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkMisc,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkProgressBar
Gtk224.GtkProgressBar = {
  class = "GtkProgressBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new                 = { gencode = "gtk_progress_bar_new()", 
            params = { type = {}, name = {} } },
    new_with_adjustment = { gencode = "gtk_progress_bar_new_with_adjustment((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activity_blocks = {__type__="guint"                     ,__default__ = "5"                          , __gencode__ = {"gtk_progress_bar_set_activity_blocks((GtkProgressBar*)({* id *}), (guint)({* property.value *}))"} },
    activity_step   = {__type__="guint"                     ,__default__ = "3"                          , __gencode__ = {"gtk_progress_bar_set_activity_step((GtkProgressBar*)({* id *}), (guint)({* property.value *}))"} },
    adjustment      = {__type__="GtkAdjustment*"                                                        ,rwflags="rw" },
    bar_style       = {__type__="GtkProgressBarStyle"       ,__default__ = "GTK_PROGRESS_CONTINUOUS"    , __gencode__ = {"gtk_progress_bar_set_bar_style((GtkProgressBar*)({* id *}), (GtkProgressBarStyle)({* property.value *}))"} },
    discrete_blocks = {__type__="guint"                     ,__default__ = "10"                         , __gencode__ = {"gtk_progress_bar_set_discrete_blocks((GtkProgressBar*)({* id *}), (guint)({* property.value *}))"} },
    ellipsize       = {__type__="PangoEllipsizeMode"        ,__default__ = "PANGO_ELLIPSIZE_NONE"       , __gencode__ = {"gtk_progress_bar_set_ellipsize((GtkProgressBar*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    fraction        = {__type__="gdouble"                   ,__default__ = "0"                          , __gencode__ = {"gtk_progress_bar_set_fraction((GtkProgressBar*)({* id *}), (gdouble)({* property.value *}))"} },
    orientation     = {__type__="GtkProgressBarOrientation" ,__default__ = "GTK_PROGRESS_LEFT_TO_RIGHT" , __gencode__ = {"gtk_progress_bar_set_orientation((GtkProgressBar*)({* id *}), (GtkProgressBarOrientation)({* property.value *}))"} },
    pulse_step      = {__type__="gdouble"                   ,__default__ = "0.1"                        , __gencode__ = {"gtk_progress_bar_set_pulse_step((GtkProgressBar*)({* id *}), (gdouble)({* property.value *}))"} },
    text            = {__type__="gchar*"                    ,__default__ = "NULL"                       , __gencode__ = {"gtk_progress_bar_set_text((GtkProgressBar*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkProgress,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkScale
Gtk224.GtkScale = {
  class = "GtkScale", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    draw_value         = {"void"  , {"GtkScale*"}, {"scale"} }, 
    format_value       = {"gchar*", {"GtkScale*", "gdouble"}, {"scale", "value"} }, 
    get_layout_offsets = {"void"  , {"GtkScale*", "gint*", "gint*"}, {"scale", "x", "y"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['format-value'] = {ret_type = "gchar*", params = {type = {"GtkScale*", "gdouble"}, name ={"scale", "value"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    digits     = {__type__="gint"            ,__default__ = "1"           , __gencode__ = {"gtk_scale_set_digits((GtkScale*)({* id *}), (gint)({* property.value *}))"} },
    draw_value = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_scale_set_draw_value((GtkScale*)({* id *}), (gboolean)({* property.value *}))"} },
    value_pos  = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP" , __gencode__ = {"gtk_scale_set_value_pos((GtkScale*)({* id *}), (GtkPositionType)({* property.value *}))"} },
  },
  parent = Gtk224.GtkRange,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkScrollbar
Gtk224.GtkScrollbar = {
  class = "GtkScrollbar", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkRange,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkSocket
Gtk224.GtkSocket = {
  class = "GtkSocket", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_socket_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    plug_added   = {"void"    , {"GtkSocket*"}, {"socket_"} }, 
    plug_removed = {"gboolean", {"GtkSocket*"}, {"socket_"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['plug-added']   = {ret_type = "void"    , params = {type = {"GtkSocket*"}, name ={"socket"}} }, 
    ['plug-removed'] = {ret_type = "gboolean", params = {type = {"GtkSocket*"}, name ={"socket"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkSpinButton
Gtk224.GtkSpinButton = {
  class = "GtkSpinButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_spin_button_new((GtkAdjustment*)({* this.adjustment.value *}), (gdouble)({* this.climb_rate.value *}), (guint)({* this.digits.value *}))", 
            params = { type = {"GtkAdjustment*", "gdouble", "guint"}, 
                       name = {"adjustment", "climb_rate", "digits"} } },
    new_with_range = { gencode = "gtk_spin_button_new_with_range((gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    change_value  = {"void", {"GtkSpinButton*", "GtkScrollType"}, {"spin_button", "scroll"} }, 
    input         = {"gint", {"GtkSpinButton*", "gdouble*"}, {"spin_button", "new_value"} }, 
    output        = {"gint", {"GtkSpinButton*"}, {"spin_button"} }, 
    value_changed = {"void", {"GtkSpinButton*"}, {"spin_button"} }, 
    wrapped       = {"void", {"GtkSpinButton*"}, {"spin_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-value']  = {ret_type = "void", params = {type = {"GtkSpinButton*", "GtkScrollType"}, name ={"spinbutton", "object"}} }, 
    input             = {ret_type = "gint", params = {type = {"GtkSpinButton*", "gdouble*"}, name ={"spin_button", "new_value"}} }, 
    output            = {ret_type = "gint", params = {type = {"GtkSpinButton*"}, name ={"spin_button"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkSpinButton*"}, name ={"spinbutton"}} }, 
    wrapped           = {ret_type = "void", params = {type = {"GtkSpinButton*"}, name ={"spin_button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment    = {__type__="GtkAdjustment*"                                               , __gencode__ = {"gtk_spin_button_set_adjustment((GtkSpinButton*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    climb_rate    = {__type__="gdouble"                   ,__default__ = "0"                 ,rwflags="rw" },
    digits        = {__type__="guint"                     ,__default__ = "0"                 , __gencode__ = {"gtk_spin_button_set_digits((GtkSpinButton*)({* id *}), (guint)({* property.value *}))"} },
    numeric       = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_numeric((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
    snap_to_ticks = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_snap_to_ticks((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
    update_policy = {__type__="GtkSpinButtonUpdatePolicy" ,__default__ = "GTK_UPDATE_ALWAYS" , __gencode__ = {"gtk_spin_button_set_update_policy((GtkSpinButton*)({* id *}), (GtkSpinButtonUpdatePolicy)({* property.value *}))"} },
    value         = {__type__="gdouble"                   ,__default__ = "0"                 , __gencode__ = {"gtk_spin_button_set_value((GtkSpinButton*)({* id *}), (gdouble)({* property.value *}))"} },
    wrap          = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_wrap((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkEntry,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellEditable, Gtk224.GtkEditable}, 
};

---------------------  GtkSpinner
Gtk224.GtkSpinner = {
  class = "GtkSpinner", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_spinner_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = Gtk224.GtkDrawingArea,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkTable
Gtk224.GtkTable = {
  class = "GtkTable", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_table_new((guint)({* this.rows.value *}), (guint)({* this.columns.value *}), (gboolean)({* this.homogeneous.value *}))", 
            params = { type = {"gboolean"}, 
                       name = {"homogeneous"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    column_spacing = {__type__="guint"    ,__default__ = "0"     ,rwflags="rw" },
    homogeneous    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_table_set_homogeneous((GtkTable*)({* id *}), (gboolean)({* property.value *}))"} },
    n_columns      = {__type__="guint"    ,__default__ = "1"     ,rwflags="rw" },
    n_rows         = {__type__="guint"    ,__default__ = "1"     ,rwflags="rw" },
    row_spacing    = {__type__="guint"    ,__default__ = "0"     , __gencode__ = {"gtk_table_set_row_spacing((GtkTable*)({* id *}), (guint)({* property.value *}), (guint)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    bottom_attach = {__type__="guint"            ,__default__ = "1" },
    left_attach   = {__type__="guint"            ,__default__ = "0" },
    right_attach  = {__type__="guint"            ,__default__ = "1" },
    top_attach    = {__type__="guint"            ,__default__ = "0" },
    x_options     = {__type__="GtkAttachOptions" ,__default__ = "GTK_EXPAND | GTK_FILL" },
    x_padding     = {__type__="guint"            ,__default__ = "0" },
    y_options     = {__type__="GtkAttachOptions" ,__default__ = "GTK_EXPAND | GTK_FILL" },
    y_padding     = {__type__="guint"            ,__default__ = "0" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkTextView
Gtk224.GtkTextView = {
  class = "GtkTextView", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_text_view_new()", 
            params = { type = {}, name = {} } },
    new_with_buffer = { gencode = "gtk_text_view_new_with_buffer((GtkTextBuffer*)({* this.buffer.value *}))", 
            params = { type = {"GtkTextBuffer*"}, 
                       name = {"buffer"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    backspace              = {"void", {"GtkTextView*"}, {"text_view"} }, 
    copy_clipboard         = {"void", {"GtkTextView*"}, {"text_view"} }, 
    cut_clipboard          = {"void", {"GtkTextView*"}, {"text_view"} }, 
    delete_from_cursor     = {"void", {"GtkTextView*", "GtkDeleteType", "gint"}, {"text_view", "type", "count"} }, 
    insert_at_cursor       = {"void", {"GtkTextView*", "const gchar*"}, {"text_view", "str"} }, 
    move_cursor            = {"void", {"GtkTextView*", "GtkMovementStep", "gint", "gboolean"}, {"text_view", "step", "count", "extend_selection"} }, 
    move_focus             = {"void", {"GtkTextView*", "GtkDirectionType"}, {"text_view", "direction"} }, 
    page_horizontally      = {"void", {"GtkTextView*", "gint", "gboolean"}, {"text_view", "count", "extend_selection"} }, 
    paste_clipboard        = {"void", {"GtkTextView*"}, {"text_view"} }, 
    populate_popup         = {"void", {"GtkTextView*", "GtkMenu*"}, {"text_view", "menu"} }, 
    set_anchor             = {"void", {"GtkTextView*"}, {"text_view"} }, 
    set_scroll_adjustments = {"void", {"GtkTextView*", "GtkAdjustment*", "GtkAdjustment*"}, {"text_view", "hadjustment", "vadjustment"} }, 
    toggle_overwrite       = {"void", {"GtkTextView*"}, {"text_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    backspace                  = {ret_type = "void", params = {type = {"GtkTextView*"}, name ={"text_view"}} }, 
    ['copy-clipboard']         = {ret_type = "void", params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['cut-clipboard']          = {ret_type = "void", params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['delete-from-cursor']     = {ret_type = "void", params = {type = {"GtkTextView*", "GtkDeleteType", "gint"}, name ={"textview", "type", "count"}} }, 
    ['insert-at-cursor']       = {ret_type = "void", params = {type = {"GtkTextView*", "gchar*"}, name ={"textview", "string"}} }, 
    ['move-cursor']            = {ret_type = "void", params = {type = {"GtkTextView*", "GtkMovementStep", "gint", "gboolean"}, name ={"textview", "step", "count", "extend_selection"}} }, 
    ['move-viewport']          = {ret_type = "void", params = {type = {"GtkTextView*", "GtkScrollStep", "gint"}, name ={"textview", "step", "count"}} }, 
    ['page-horizontally']      = {ret_type = "void", params = {type = {"GtkTextView*", "gint", "gboolean"}, name ={"textview", "count", "extend_selection"}} }, 
    ['paste-clipboard']        = {ret_type = "void", params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['populate-popup']         = {ret_type = "void", params = {type = {"GtkTextView*", "GtkMenu*"}, name ={"textview", "menu"}} }, 
    ['preedit-changed']        = {ret_type = "void", params = {type = {"GtkTextView*", "gchar*"}, name ={"textview", "preedit"}} }, 
    ['select-all']             = {ret_type = "void", params = {type = {"GtkTextView*", "gboolean"}, name ={"textview", "select"}} }, 
    ['set-anchor']             = {ret_type = "void", params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['set-scroll-adjustments'] = {ret_type = "void", params = {type = {"GtkTextView*", "GtkAdjustment*", "GtkAdjustment*"}, name ={"textview", "object", "p0"}} }, 
    ['toggle-cursor-visible']  = {ret_type = "void", params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['toggle-overwrite']       = {ret_type = "void", params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accepts_tab        = {__type__="gboolean"         ,__default__ = "TRUE"             , __gencode__ = {"gtk_text_view_set_accepts_tab((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    buffer             = {__type__="GtkTextBuffer*"                                     , __gencode__ = {"gtk_text_view_set_buffer((GtkTextView*)({* id *}), (GtkTextBuffer*)({* property.value *}))"} },
    cursor_visible     = {__type__="gboolean"         ,__default__ = "TRUE"             , __gencode__ = {"gtk_text_view_set_cursor_visible((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    editable           = {__type__="gboolean"         ,__default__ = "TRUE"             , __gencode__ = {"gtk_text_view_set_editable((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    im_module          = {__type__="gchar*"           ,__default__ = "NULL"             ,rwflags="rw" },
    indent             = {__type__="gint"             ,__default__ = "0"                , __gencode__ = {"gtk_text_view_set_indent((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    justification      = {__type__="GtkJustification" ,__default__ = "GTK_JUSTIFY_LEFT" , __gencode__ = {"gtk_text_view_set_justification((GtkTextView*)({* id *}), (GtkJustification)({* property.value *}))"} },
    left_margin        = {__type__="gint"             ,__default__ = "0"                , __gencode__ = {"gtk_text_view_set_left_margin((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    overwrite          = {__type__="gboolean"         ,__default__ = "FALSE"            , __gencode__ = {"gtk_text_view_set_overwrite((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    pixels_above_lines = {__type__="gint"             ,__default__ = "0"                , __gencode__ = {"gtk_text_view_set_pixels_above_lines((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    pixels_below_lines = {__type__="gint"             ,__default__ = "0"                , __gencode__ = {"gtk_text_view_set_pixels_below_lines((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    pixels_inside_wrap = {__type__="gint"             ,__default__ = "0"                , __gencode__ = {"gtk_text_view_set_pixels_inside_wrap((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    right_margin       = {__type__="gint"             ,__default__ = "0"                , __gencode__ = {"gtk_text_view_set_right_margin((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    tabs               = {__type__="PangoTabArray*"                                     , __gencode__ = {"gtk_text_view_set_tabs((GtkTextView*)({* id *}), (PangoTabArray*)({* property.value *}))"} },
    wrap_mode          = {__type__="GtkWrapMode"      ,__default__ = "GTK_WRAP_NONE"    , __gencode__ = {"gtk_text_view_set_wrap_mode((GtkTextView*)({* id *}), (GtkWrapMode)({* property.value *}))"} },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkToolItemGroup
Gtk224.GtkToolItemGroup = {
  class = "GtkToolItemGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tool_item_group_new((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    collapsed     = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_tool_item_group_set_collapsed((GtkToolItemGroup*)({* id *}), (gboolean)({* property.value *}))"} },
    ellipsize     = {__type__="PangoEllipsizeMode" ,__default__ = "PANGO_ELLIPSIZE_NONE" , __gencode__ = {"gtk_tool_item_group_set_ellipsize((GtkToolItemGroup*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    header_relief = {__type__="GtkReliefStyle"     ,__default__ = "GTK_RELIEF_NORMAL"    , __gencode__ = {"gtk_tool_item_group_set_header_relief((GtkToolItemGroup*)({* id *}), (GtkReliefStyle)({* property.value *}))"} },
    label         = {__type__="gchar*"             ,__default__ = "\"\""                 , __gencode__ = {"gtk_tool_item_group_set_label((GtkToolItemGroup*)({* id *}), (const gchar*)({* property.value *}))"} },
    label_widget  = {__type__="GtkWidget*"                                               , __gencode__ = {"gtk_tool_item_group_set_label_widget((GtkToolItemGroup*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    expand      = {__type__="gboolean" ,__default__ = "FALSE" },
    fill        = {__type__="gboolean" ,__default__ = "TRUE" },
    homogeneous = {__type__="gboolean" ,__default__ = "TRUE" },
    new_row     = {__type__="gboolean" ,__default__ = "FALSE" },
    position    = {__type__="gint"     ,__default__ = "0" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkToolShell}, 
};

---------------------  GtkToolPalette
Gtk224.GtkToolPalette = {
  class = "GtkToolPalette", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tool_palette_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['set-scroll-adjustments'] = {ret_type = "void", params = {type = {"GtkToolPalette*", "GtkAdjustment*", "GtkAdjustment*"}, name ={"toolpalette", "hadjustment", "vadjustment"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    icon_size     = {__type__="GtkIconSize"     ,__default__ = "GTK_ICON_SIZE_SMALL_TOOLBAR" , __gencode__ = {"gtk_tool_palette_set_icon_size((GtkToolPalette*)({* id *}), (GtkIconSize)({* property.value *}))"} },
    icon_size_set = {__type__="gboolean"        ,__default__ = "FALSE"                       ,rwflags="rw" },
    toolbar_style = {__type__="GtkToolbarStyle" ,__default__ = "GTK_TOOLBAR_ICONS"           ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    exclusive = {__type__="gboolean" ,__default__ = "FALSE" },
    expand    = {__type__="gboolean" ,__default__ = "FALSE" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkToolbar
Gtk224.GtkToolbar = {
  class = "GtkToolbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_toolbar_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    orientation_changed = {"void"    , {"GtkToolbar*", "GtkOrientation"}, {"toolbar", "orientation"} }, 
    popup_context_menu  = {"gboolean", {"GtkToolbar*", "gint", "gint", "gint"}, {"toolbar", "x", "y", "button_number"} }, 
    style_changed       = {"void"    , {"GtkToolbar*", "GtkToolbarStyle"}, {"toolbar", "style"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['focus-home-or-end']   = {ret_type = "gboolean", params = {type = {"GtkToolbar*", "gboolean"}, name ={"toolbar", "focus_home"}} }, 
    ['orientation-changed'] = {ret_type = "void"    , params = {type = {"GtkToolbar*", "GtkOrientation"}, name ={"toolbar", "orientation"}} }, 
    ['popup-context-menu']  = {ret_type = "gboolean", params = {type = {"GtkToolbar*", "gint", "gint", "gint"}, name ={"toolbar", "x", "y", "button"}} }, 
    ['style-changed']       = {ret_type = "void"    , params = {type = {"GtkToolbar*", "GtkToolbarStyle"}, name ={"toolbar", "style"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    icon_size     = {__type__="gint"            ,__default__ = "3"                , __gencode__ = {"gtk_toolbar_set_icon_size((GtkToolbar*)({* id *}), (GtkIconSize)({* property.value *}))"} },
    icon_size_set = {__type__="gboolean"        ,__default__ = "FALSE"            ,rwflags="rw" },
    show_arrow    = {__type__="gboolean"        ,__default__ = "TRUE"             , __gencode__ = {"gtk_toolbar_set_show_arrow((GtkToolbar*)({* id *}), (gboolean)({* property.value *}))"} },
    toolbar_style = {__type__="GtkToolbarStyle" ,__default__ = "GTK_TOOLBAR_BOTH" ,rwflags="rw" },
    tooltips      = {__type__="gboolean"        ,__default__ = "TRUE"             , __gencode__ = {"gtk_toolbar_set_tooltips((GtkToolbar*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    expand      = {__type__="gboolean" ,__default__ = "FALSE" },
    homogeneous = {__type__="gboolean" ,__default__ = "FALSE" },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable, Gtk224.GtkToolShell}, 
};

---------------------  GtkTreeView
Gtk224.GtkTreeView = {
  class = "GtkTreeView", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_tree_view_new()", 
            params = { type = {}, name = {} } },
    new_with_model = { gencode = "gtk_tree_view_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    columns_changed            = {"void"    , {"GtkTreeView*"}, {"tree_view"} }, 
    cursor_changed             = {"void"    , {"GtkTreeView*"}, {"tree_view"} }, 
    expand_collapse_cursor_row = {"gboolean", {"GtkTreeView*", "gboolean", "gboolean", "gboolean"}, {"tree_view", "logical", "expand", "open_all"} }, 
    move_cursor                = {"gboolean", {"GtkTreeView*", "GtkMovementStep", "gint"}, {"tree_view", "step", "count"} }, 
    row_activated              = {"void"    , {"GtkTreeView*", "GtkTreePath*", "GtkTreeViewColumn*"}, {"tree_view", "path", "column"} }, 
    row_collapsed              = {"void"    , {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    row_expanded               = {"void"    , {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    select_all                 = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    select_cursor_parent       = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    select_cursor_row          = {"gboolean", {"GtkTreeView*", "gboolean"}, {"tree_view", "start_editing"} }, 
    set_scroll_adjustments     = {"void"    , {"GtkTreeView*", "GtkAdjustment*", "GtkAdjustment*"}, {"tree_view", "hadjustment", "vadjustment"} }, 
    start_interactive_search   = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    test_collapse_row          = {"gboolean", {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    test_expand_row            = {"gboolean", {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    toggle_cursor_row          = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    unselect_all               = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['columns-changed']            = {ret_type = "void"    , params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['cursor-changed']             = {ret_type = "void"    , params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['expand-collapse-cursor-row'] = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "gboolean", "gboolean", "gboolean"}, name ={"treeview", "object", "p0", "p1"}} }, 
    ['move-cursor']                = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkMovementStep", "gint"}, name ={"treeview", "object", "p0"}} }, 
    ['row-activated']              = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreePath*", "GtkTreeViewColumn*"}, name ={"treeview", "path", "column"}} }, 
    ['row-collapsed']              = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['row-expanded']               = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['select-all']                 = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['select-cursor-parent']       = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['select-cursor-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "gboolean"}, name ={"treeview", "object"}} }, 
    ['set-scroll-adjustments']     = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkAdjustment*", "GtkAdjustment*"}, name ={"treeview", "object", "p0"}} }, 
    ['start-interactive-search']   = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['test-collapse-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['test-expand-row']            = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['toggle-cursor-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['unselect-all']               = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    enable_grid_lines = {__type__="GtkTreeViewGridLines" ,__default__ = "GTK_TREE_VIEW_GRID_LINES_NONE" ,rwflags="rw" },
    enable_search     = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_enable_search((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    enable_tree_lines = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_enable_tree_lines((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    expander_column   = {__type__="GtkTreeViewColumn*"                                                  , __gencode__ = {"gtk_tree_view_set_expander_column((GtkTreeView*)({* id *}), (GtkTreeViewColumn*)({* property.value *}))"} },
    fixed_height_mode = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_fixed_height_mode((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    hadjustment       = {__type__="GtkAdjustment*"                                                      , __gencode__ = {"gtk_tree_view_set_hadjustment((GtkTreeView*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    headers_clickable = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_headers_clickable((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    headers_visible   = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_headers_visible((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    hover_expand      = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_hover_expand((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    hover_selection   = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_hover_selection((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    level_indentation = {__type__="gint"                 ,__default__ = "0"                             , __gencode__ = {"gtk_tree_view_set_level_indentation((GtkTreeView*)({* id *}), (gint)({* property.value *}))"} },
    model             = {__type__="GtkTreeModel*"                                                       , __gencode__ = {"gtk_tree_view_set_model((GtkTreeView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    reorderable       = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_reorderable((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    rubber_banding    = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_rubber_banding((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    rules_hint        = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_rules_hint((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    search_column     = {__type__="gint"                 ,__default__ = "-1"                            , __gencode__ = {"gtk_tree_view_set_search_column((GtkTreeView*)({* id *}), (gint)({* property.value *}))"} },
    show_expanders    = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_show_expanders((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    tooltip_column    = {__type__="gint"                 ,__default__ = "-1"                            , __gencode__ = {"gtk_tree_view_set_tooltip_column((GtkTreeView*)({* id *}), (gint)({* property.value *}))"} },
    vadjustment       = {__type__="GtkAdjustment*"                                                      , __gencode__ = {"gtk_tree_view_set_vadjustment((GtkTreeView*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkContainer,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkVRuler
Gtk224.GtkVRuler = {
  class = "GtkVRuler", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vruler_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkRuler,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkVSeparator
Gtk224.GtkVSeparator = {
  class = "GtkVSeparator", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vseparator_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkSeparator,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkAccelLabel
Gtk224.GtkAccelLabel = {
  class = "GtkAccelLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_accel_label_new((const gchar*)({* this.string.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accel_closure = {__type__="GClosure*"  , __gencode__ = {"gtk_accel_label_set_accel_closure((GtkAccelLabel*)({* id *}), (GClosure*)({* property.value *}))"} },
    accel_widget  = {__type__="GtkWidget*" , __gencode__ = {"gtk_accel_label_set_accel_widget((GtkAccelLabel*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkLabel,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkAlignment
Gtk224.GtkAlignment = {
  class = "GtkAlignment", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_alignment_new((gfloat)({* this.xalign.value *}), (gfloat)({* this.yalign.value *}), (gfloat)({* this.xscale.value *}), (gfloat)({* this.yscale.value *}))", 
            params = { type = {"gfloat", "gfloat", "gfloat", "gfloat"}, 
                       name = {"xalign", "yalign", "xscale", "yscale"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    bottom_padding = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    left_padding   = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    right_padding  = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    top_padding    = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    xalign         = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    xscale         = {__type__="gfloat" ,__default__ = "1"   ,rwflags="rw" },
    yalign         = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    yscale         = {__type__="gfloat" ,__default__ = "1"   ,rwflags="rw" },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkButton
Gtk224.GtkButton = {
  class = "GtkButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_button_new()", 
            params = { type = {}, name = {} } },
    new_from_stock    = { gencode = "gtk_button_new_from_stock((const gchar*)({* this.stock_id.value *}))", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_button_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_button_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkButton*"}, {"button"} }, 
    clicked  = {"void", {"GtkButton*"}, {"button"} }, 
    enter    = {"void", {"GtkButton*"}, {"button"} }, 
    leave    = {"void", {"GtkButton*"}, {"button"} }, 
    pressed  = {"void", {"GtkButton*"}, {"button"} }, 
    released = {"void", {"GtkButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    clicked  = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    enter    = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    leave    = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    pressed  = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    released = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    focus_on_click = {__type__="gboolean"        ,__default__ = "TRUE"              , __gencode__ = {"gtk_button_set_focus_on_click((GtkButton*)({* id *}), (gboolean)({* property.value *}))"} },
    image          = {__type__="GtkWidget*"                                         , __gencode__ = {"gtk_button_set_image((GtkButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    image_position = {__type__="GtkPositionType" ,__default__ = "GTK_POS_LEFT"      , __gencode__ = {"gtk_button_set_image_position((GtkButton*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    label          = {__type__="gchar*"          ,__default__ = "NULL"              , __gencode__ = {"gtk_button_set_label((GtkButton*)({* id *}), (const gchar*)({* property.value *}))"},__construct__= 1 },
    relief         = {__type__="GtkReliefStyle"  ,__default__ = "GTK_RELIEF_NORMAL" , __gencode__ = {"gtk_button_set_relief((GtkButton*)({* id *}), (GtkReliefStyle)({* property.value *}))"} },
    use_stock      = {__type__="gboolean"        ,__default__ = "FALSE"             , __gencode__ = {"gtk_button_set_use_stock((GtkButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    use_underline  = {__type__="gboolean"        ,__default__ = "FALSE"             , __gencode__ = {"gtk_button_set_use_underline((GtkButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    xalign         = {__type__="gfloat"          ,__default__ = "0.5"               ,rwflags="rw" },
    yalign         = {__type__="gfloat"          ,__default__ = "0.5"               ,rwflags="rw" },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkButtonBox
Gtk224.GtkButtonBox = {
  class = "GtkButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    layout_style = {__type__="GtkButtonBoxStyle" ,__default__ = "GTK_BUTTONBOX_DEFAULT_STYLE" ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    secondary = {__type__="gboolean" ,__default__ = "FALSE" },
  },
  parent = Gtk224.GtkBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkCTree
Gtk224.GtkCTree = {
  class = "GtkCTree", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_ctree_new((gint)({* this.columns.value *}), (gint)({* this.tree_column.value *}))", 
            params = { type = {"gint"}, 
                       name = {"tree_column"} } },
    new_with_titles = { gencode = "gtk_ctree_new_with_titles((gint)({* this.columns.value *}), (gint)({* this.tree_column.value *}), (gchar**)({* this.titles.value *}))", 
            params = { type = {"gint"}, 
                       name = {"tree_column"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    change_focus_row_expansion = {"void", {"GtkCTree*", "GtkCTreeExpansionType"}, {"ctree", "action"} }, 
    tree_collapse              = {"void", {"GtkCTree*", "GtkCTreeNode*"}, {"ctree", "node"} }, 
    tree_expand                = {"void", {"GtkCTree*", "GtkCTreeNode*"}, {"ctree", "node"} }, 
    tree_move                  = {"void", {"GtkCTree*", "GtkCTreeNode*", "GtkCTreeNode*", "GtkCTreeNode*"}, {"ctree", "node", "new_parent", "new_sibling"} }, 
    tree_select_row            = {"void", {"GtkCTree*", "GtkCTreeNode*", "gint"}, {"ctree", "row", "column"} }, 
    tree_unselect_row          = {"void", {"GtkCTree*", "GtkCTreeNode*", "gint"}, {"ctree", "row", "column"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-focus-row-expansion'] = {ret_type = "void", params = {type = {"GtkCTree*", "GtkCTreeExpansionType"}, name ={"ctree", "object"}} }, 
    ['tree-collapse']              = {ret_type = "void", params = {type = {"GtkCTree*", "void"}, name ={"ctree", "object"}} }, 
    ['tree-expand']                = {ret_type = "void", params = {type = {"GtkCTree*", "void"}, name ={"ctree", "object"}} }, 
    ['tree-move']                  = {ret_type = "void", params = {type = {"GtkCTree*", "void", "void", "void"}, name ={"ctree", "object", "p0", "p1"}} }, 
    ['tree-select-row']            = {ret_type = "void", params = {type = {"GtkCTree*", "void", "gint"}, name ={"ctree", "object", "p0"}} }, 
    ['tree-unselect-row']          = {ret_type = "void", params = {type = {"GtkCTree*", "void", "gint"}, name ={"ctree", "object", "p0"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    expander_style = {__type__="GtkCTreeExpanderStyle" ,__default__ = "GTK_CTREE_EXPANDER_NONE" , __gencode__ = {"gtk_ctree_set_expander_style((GtkCTree*)({* id *}), (GtkCTreeExpanderStyle)({* property.value *}))"} },
    indent         = {__type__="guint"                 ,__default__ = "0"                       , __gencode__ = {"gtk_ctree_set_indent((GtkCTree*)({* id *}), (gint)({* property.value *}))"} },
    line_style     = {__type__="GtkCTreeLineStyle"     ,__default__ = "GTK_CTREE_LINES_NONE"    , __gencode__ = {"gtk_ctree_set_line_style((GtkCTree*)({* id *}), (GtkCTreeLineStyle)({* property.value *}))"} },
    n_columns      = {__type__="guint"                 ,__default__ = "0"                       ,rwflags="rw" },
    show_stub      = {__type__="gboolean"              ,__default__ = "FALSE"                   , __gencode__ = {"gtk_ctree_set_show_stub((GtkCTree*)({* id *}), (gboolean)({* property.value *}))"} },
    spacing        = {__type__="guint"                 ,__default__ = "0"                       , __gencode__ = {"gtk_ctree_set_spacing((GtkCTree*)({* id *}), (gint)({* property.value *}))"} },
    tree_column    = {__type__="guint"                 ,__default__ = "0"                       ,rwflags="rw" },
  },
  parent = Gtk224.GtkCList,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkComboBox
Gtk224.GtkComboBox = {
  class = "GtkComboBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new                      = { gencode = "gtk_combo_box_new()", 
            params = { type = {}, name = {} } },
    new_text                 = { gencode = "gtk_combo_box_new_text()", 
            params = { type = {}, name = {} } },
    new_with_entry           = { gencode = "gtk_combo_box_new_with_entry()", 
            params = { type = {}, name = {} } },
    new_with_model           = { gencode = "gtk_combo_box_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
    new_with_model_and_entry = { gencode = "gtk_combo_box_new_with_model_and_entry((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed         = {"void"  , {"GtkComboBox*"}, {"combo_box"} }, 
    get_active_text = {"gchar*", {"GtkComboBox*"}, {"combo_box"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed         = {ret_type = "void"    , params = {type = {"GtkComboBox*"}, name ={"combo_box"}} }, 
    ['move-active'] = {ret_type = "void"    , params = {type = {"GtkComboBox*", "GtkScrollType"}, name ={"combobox", "scroll_type"}} }, 
    popdown         = {ret_type = "gboolean", params = {type = {"GtkComboBox*"}, name ={"combobox"}} }, 
    popup           = {ret_type = "void"    , params = {type = {"GtkComboBox*"}, name ={"combobox"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active             = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_active((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    add_tearoffs       = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_combo_box_set_add_tearoffs((GtkComboBox*)({* id *}), (gboolean)({* property.value *}))"} },
    button_sensitivity = {__type__="GtkSensitivityType" ,__default__ = "GTK_SENSITIVITY_AUTO" , __gencode__ = {"gtk_combo_box_set_button_sensitivity((GtkComboBox*)({* id *}), (GtkSensitivityType)({* property.value *}))"} },
    column_span_column = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_column_span_column((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    entry_text_column  = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_entry_text_column((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    focus_on_click     = {__type__="gboolean"           ,__default__ = "TRUE"                 , __gencode__ = {"gtk_combo_box_set_focus_on_click((GtkComboBox*)({* id *}), (gboolean)({* property.value *}))"} },
    has_entry          = {__type__="gboolean"           ,__default__ = "FALSE"                ,rwflags="rw" },
    has_frame          = {__type__="gboolean"           ,__default__ = "TRUE"                 ,rwflags="rw" },
    model              = {__type__="GtkTreeModel*"                                            , __gencode__ = {"gtk_combo_box_set_model((GtkComboBox*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    popup_shown        = {__type__="gboolean"           ,__default__ = "FALSE"                 },
    row_span_column    = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_row_span_column((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    tearoff_title      = {__type__="gchar*"             ,__default__ = "NULL"                 ,rwflags="rw" },
    wrap_width         = {__type__="gint"               ,__default__ = "0"                    , __gencode__ = {"gtk_combo_box_set_wrap_width((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellEditable, Gtk224.GtkCellLayout}, 
};

---------------------  GtkEventBox
Gtk224.GtkEventBox = {
  class = "GtkEventBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    above_child    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_event_box_set_above_child((GtkEventBox*)({* id *}), (gboolean)({* property.value *}))"} },
    visible_window = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_event_box_set_visible_window((GtkEventBox*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkExpander
Gtk224.GtkExpander = {
  class = "GtkExpander", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_expander_new((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_expander_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkExpander*"}, {"expander"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkExpander*"}, name ={"expander"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    expanded      = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_expanded((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    label         = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_expander_set_label((GtkExpander*)({* id *}), (const gchar*)({* property.value *}))"},__construct__= 1 },
    label_fill    = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_label_fill((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    label_widget  = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_expander_set_label_widget((GtkExpander*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    spacing       = {__type__="gint"       ,__default__ = "0"     , __gencode__ = {"gtk_expander_set_spacing((GtkExpander*)({* id *}), (gint)({* property.value *}))"} },
    use_markup    = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_use_markup((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    use_underline = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_use_underline((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkFrame
Gtk224.GtkFrame = {
  class = "GtkFrame", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_frame_new((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    compute_child_allocation = {"void", {"GtkFrame*", "GtkAllocation*"}, {"frame", "allocation"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    label        = {__type__="gchar*"        ,__default__ = "NULL"                 , __gencode__ = {"gtk_frame_set_label((GtkFrame*)({* id *}), (const gchar*)({* property.value *}))"} },
    label_widget = {__type__="GtkWidget*"                                          , __gencode__ = {"gtk_frame_set_label_widget((GtkFrame*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    label_xalign = {__type__="gfloat"        ,__default__ = "0"                    ,rwflags="rw" },
    label_yalign = {__type__="gfloat"        ,__default__ = "0.5"                  ,rwflags="rw" },
    shadow       = {__type__="GtkShadowType" ,__default__ = "GTK_SHADOW_ETCHED_IN" ,rwflags="rw" },
    shadow_type  = {__type__="GtkShadowType" ,__default__ = "GTK_SHADOW_ETCHED_IN" , __gencode__ = {"gtk_frame_set_shadow_type((GtkFrame*)({* id *}), (GtkShadowType)({* property.value *}))"} },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkHBox
Gtk224.GtkHBox = {
  class = "GtkHBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hbox_new((gboolean)({* this.homogeneous.value *}), (gint)({* this.spacing.value *}))", 
            params = { type = {"gboolean", "gint"}, 
                       name = {"homogeneous", "spacing"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkHPaned
Gtk224.GtkHPaned = {
  class = "GtkHPaned", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hpaned_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkPaned,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkHScale
Gtk224.GtkHScale = {
  class = "GtkHScale", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_hscale_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
    new_with_range = { gencode = "gtk_hscale_new_with_range((gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkScale,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkHScrollbar
Gtk224.GtkHScrollbar = {
  class = "GtkHScrollbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hscrollbar_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkScrollbar,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkHandleBox
Gtk224.GtkHandleBox = {
  class = "GtkHandleBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_handle_box_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    child_attached = {"void", {"GtkHandleBox*", "GtkWidget*"}, {"handle_box", "child"} }, 
    child_detached = {"void", {"GtkHandleBox*", "GtkWidget*"}, {"handle_box", "child"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['child-attached'] = {ret_type = "void", params = {type = {"GtkHandleBox*", "GtkWidget*"}, name ={"handlebox", "object"}} }, 
    ['child-detached'] = {ret_type = "void", params = {type = {"GtkHandleBox*", "GtkWidget*"}, name ={"handlebox", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child_detached  = {__type__="gboolean"        ,__default__ = "FALSE"           },
    handle_position = {__type__="GtkPositionType" ,__default__ = "GTK_POS_LEFT"   , __gencode__ = {"gtk_handle_box_set_handle_position((GtkHandleBox*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    shadow          = {__type__="GtkShadowType"   ,__default__ = "GTK_SHADOW_OUT" ,rwflags="rw" },
    shadow_type     = {__type__="GtkShadowType"   ,__default__ = "GTK_SHADOW_OUT" , __gencode__ = {"gtk_handle_box_set_shadow_type((GtkHandleBox*)({* id *}), (GtkShadowType)({* property.value *}))"} },
    snap_edge       = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP"    , __gencode__ = {"gtk_handle_box_set_snap_edge((GtkHandleBox*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    snap_edge_set   = {__type__="gboolean"        ,__default__ = "FALSE"          ,rwflags="rw" },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkItem
Gtk224.GtkItem = {
  class = "GtkItem", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    deselect = {"void", {"GtkItem*"}, {"item"} }, 
    select   = {"void", {"GtkItem*"}, {"item"} }, 
    toggle   = {"void", {"GtkItem*"}, {"item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    deselect = {ret_type = "void", params = {type = {"GtkItem*"}, name ={"item"}} }, 
    select   = {ret_type = "void", params = {type = {"GtkItem*"}, name ={"item"}} }, 
    toggle   = {ret_type = "void", params = {type = {"GtkItem*"}, name ={"item"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkMenu
Gtk224.GtkMenu = {
  class = "GtkMenu", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_menu_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['move-scroll'] = {ret_type = "void", params = {type = {"GtkMenu*", "GtkScrollType"}, name ={"menu", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accel_group         = {__type__="GtkAccelGroup*"                        , __gencode__ = {"gtk_menu_set_accel_group((GtkMenu*)({* id *}), (GtkAccelGroup*)({* property.value *}))"} },
    accel_path          = {__type__="gchar*"         ,__default__ = "NULL"  , __gencode__ = {"gtk_menu_set_accel_path((GtkMenu*)({* id *}), (const gchar*)({* property.value *}))"} },
    active              = {__type__="gint"           ,__default__ = "-1"    , __gencode__ = {"gtk_menu_set_active((GtkMenu*)({* id *}), (guint)({* property.value *}))"} },
    attach_widget       = {__type__="GtkWidget*"                            ,rwflags="rw" },
    monitor             = {__type__="gint"           ,__default__ = "-1"    , __gencode__ = {"gtk_menu_set_monitor((GtkMenu*)({* id *}), (gint)({* property.value *}))"} },
    reserve_toggle_size = {__type__="gboolean"       ,__default__ = "TRUE"  , __gencode__ = {"gtk_menu_set_reserve_toggle_size((GtkMenu*)({* id *}), (gboolean)({* property.value *}))"} },
    tearoff_state       = {__type__="gboolean"       ,__default__ = "FALSE" , __gencode__ = {"gtk_menu_set_tearoff_state((GtkMenu*)({* id *}), (gboolean)({* property.value *}))"} },
    tearoff_title       = {__type__="gchar*"         ,__default__ = "NULL"  ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    bottom_attach = {__type__="gint" ,__default__ = "-1" },
    left_attach   = {__type__="gint" ,__default__ = "-1" },
    right_attach  = {__type__="gint" ,__default__ = "-1" },
    top_attach    = {__type__="gint" ,__default__ = "-1" },
  },
  parent = Gtk224.GtkMenuShell,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkMenuBar
Gtk224.GtkMenuBar = {
  class = "GtkMenuBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_menu_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child_pack_direction = {__type__="GtkPackDirection" ,__default__ = "GTK_PACK_DIRECTION_LTR" , __gencode__ = {"gtk_menu_bar_set_child_pack_direction((GtkMenuBar*)({* id *}), (GtkPackDirection)({* property.value *}))"} },
    pack_direction       = {__type__="GtkPackDirection" ,__default__ = "GTK_PACK_DIRECTION_LTR" , __gencode__ = {"gtk_menu_bar_set_pack_direction((GtkMenuBar*)({* id *}), (GtkPackDirection)({* property.value *}))"} },
  },
  parent = Gtk224.GtkMenuShell,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkScrolledWindow
Gtk224.GtkScrolledWindow = {
  class = "GtkScrolledWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scrolled_window_new((GtkAdjustment*)({* this.hadjustment.value *}), (GtkAdjustment*)({* this.vadjustment.value *}))", 
            params = { type = {"GtkAdjustment*", "GtkAdjustment*"}, 
                       name = {"hadjustment", "vadjustment"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    move_focus_out = {"void"    , {"GtkScrolledWindow*", "GtkDirectionType"}, {"scrolled_window", "direction"} }, 
    scroll_child   = {"gboolean", {"GtkScrolledWindow*", "GtkScrollType", "gboolean"}, {"scrolled_window", "scroll", "horizontal"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['move-focus-out'] = {ret_type = "void"    , params = {type = {"GtkScrolledWindow*", "GtkDirectionType"}, name ={"scrolledwindow", "object"}} }, 
    ['scroll-child']   = {ret_type = "gboolean", params = {type = {"GtkScrolledWindow*", "GtkScrollType", "gboolean"}, name ={"scrolledwindow", "scroll", "horizontal"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hadjustment          = {__type__="GtkAdjustment*"                                      , __gencode__ = {"gtk_scrolled_window_set_hadjustment((GtkScrolledWindow*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    hscrollbar_policy    = {__type__="GtkPolicyType"  ,__default__ = "GTK_POLICY_ALWAYS"   ,rwflags="rw" },
    shadow_type          = {__type__="GtkShadowType"  ,__default__ = "GTK_SHADOW_NONE"     , __gencode__ = {"gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)({* id *}), (GtkShadowType)({* property.value *}))"} },
    vadjustment          = {__type__="GtkAdjustment*"                                      , __gencode__ = {"gtk_scrolled_window_set_vadjustment((GtkScrolledWindow*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    vscrollbar_policy    = {__type__="GtkPolicyType"  ,__default__ = "GTK_POLICY_ALWAYS"   ,rwflags="rw" },
    window_placement     = {__type__="GtkCornerType"  ,__default__ = "GTK_CORNER_TOP_LEFT" ,rwflags="rw" },
    window_placement_set = {__type__="gboolean"       ,__default__ = "FALSE"               ,rwflags="rw" },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkTipsQuery
Gtk224.GtkTipsQuery = {
  class = "GtkTipsQuery", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tips_query_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    start_query     = {"void", {"GtkTipsQuery*"}, {"tips_query"} }, 
    stop_query      = {"void", {"GtkTipsQuery*"}, {"tips_query"} }, 
    widget_entered  = {"void", {"GtkTipsQuery*", "GtkWidget*", "const gchar*", "const gchar*"}, {"tips_query", "widget", "tip_text", "tip_private"} }, 
    widget_selected = {"gint", {"GtkTipsQuery*", "GtkWidget*", "const gchar*", "const gchar*", "GdkEventButton*"}, {"tips_query", "widget", "tip_text", "tip_private", "event"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['start-query']     = {ret_type = "void"    , params = {type = {"GtkTipsQuery*"}, name ={"tipsquery"}} }, 
    ['stop-query']      = {ret_type = "void"    , params = {type = {"GtkTipsQuery*"}, name ={"tipsquery"}} }, 
    ['widget-entered']  = {ret_type = "void"    , params = {type = {"GtkTipsQuery*", "GtkWidget*", "gchar*", "gchar*"}, name ={"tipsquery", "object", "p0", "p1"}} }, 
    ['widget-selected'] = {ret_type = "gboolean", params = {type = {"GtkTipsQuery*", "GtkWidget*", "gchar*", "gchar*", "GdkEvent*"}, name ={"tipsquery", "object", "p0", "p1", "p2"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    caller         = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_tips_query_set_caller((GtkTipsQuery*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    emit_always    = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
    label_inactive = {__type__="gchar*"     ,__default__ = "NULL"  ,rwflags="rw" },
    label_no_tip   = {__type__="gchar*"     ,__default__ = "NULL"  ,rwflags="rw" },
  },
  parent = Gtk224.GtkLabel,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkToolItem
Gtk224.GtkToolItem = {
  class = "GtkToolItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tool_item_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    create_menu_proxy    = {"gboolean", {"GtkToolItem*"}, {"tool_item"} }, 
    set_tooltip          = {"gboolean", {"GtkToolItem*", "GtkTooltips*", "const gchar*", "const gchar*"}, {"tool_item", "tooltips", "tip_text", "tip_private"} }, 
    toolbar_reconfigured = {"void"    , {"GtkToolItem*"}, {"tool_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['create-menu-proxy']    = {ret_type = "gboolean", params = {type = {"GtkToolItem*"}, name ={"toolitem"}} }, 
    ['set-tooltip']          = {ret_type = "gboolean", params = {type = {"GtkToolItem*", "GtkTooltips*", "gchar*", "gchar*"}, name ={"toolitem", "tooltips", "tip_text", "tip_private"}} }, 
    ['toolbar-reconfigured'] = {ret_type = "void"    , params = {type = {"GtkToolItem*"}, name ={"toolitem"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    is_important       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_tool_item_set_is_important((GtkToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
    visible_horizontal = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_tool_item_set_visible_horizontal((GtkToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
    visible_vertical   = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_tool_item_set_visible_vertical((GtkToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkVBox
Gtk224.GtkVBox = {
  class = "GtkVBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vbox_new((gboolean)({* this.homogeneous.value *}), (gint)({* this.spacing.value *}))", 
            params = { type = {"gboolean", "gint"}, 
                       name = {"homogeneous", "spacing"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkVPaned
Gtk224.GtkVPaned = {
  class = "GtkVPaned", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vpaned_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkPaned,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkVScale
Gtk224.GtkVScale = {
  class = "GtkVScale", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_vscale_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
    new_with_range = { gencode = "gtk_vscale_new_with_range((gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkScale,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkVScrollbar
Gtk224.GtkVScrollbar = {
  class = "GtkVScrollbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vscrollbar_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkScrollbar,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkViewport
Gtk224.GtkViewport = {
  class = "GtkViewport", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_viewport_new((GtkAdjustment*)({* this.hadjustment.value *}), (GtkAdjustment*)({* this.vadjustment.value *}))", 
            params = { type = {"GtkAdjustment*", "GtkAdjustment*"}, 
                       name = {"hadjustment", "vadjustment"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    set_scroll_adjustments = {"void", {"GtkViewport*", "GtkAdjustment*", "GtkAdjustment*"}, {"viewport", "hadjustment", "vadjustment"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['set-scroll-adjustments'] = {ret_type = "void", params = {type = {"GtkViewport*", "GtkAdjustment*", "GtkAdjustment*"}, name ={"viewport", "object", "p0"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hadjustment = {__type__="GtkAdjustment*"                                , __gencode__ = {"gtk_viewport_set_hadjustment((GtkViewport*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    shadow_type = {__type__="GtkShadowType"  ,__default__ = "GTK_SHADOW_IN" , __gencode__ = {"gtk_viewport_set_shadow_type((GtkViewport*)({* id *}), (GtkShadowType)({* property.value *}))"} },
    vadjustment = {__type__="GtkAdjustment*"                                , __gencode__ = {"gtk_viewport_set_vadjustment((GtkViewport*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkWindow
Gtk224.GtkWindow = {
  class = "GtkWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_new((GtkWindowType)({* this.type.value *}))", 
            params = { type = {"GtkWindowType"}, 
                       name = {"type"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_default = {"void"    , {"GtkWindow*"}, {"window"} }, 
    activate_focus   = {"void"    , {"GtkWindow*"}, {"window"} }, 
    frame_event      = {"gboolean", {"GtkWindow*", "GdkEvent*"}, {"window", "event"} }, 
    keys_changed     = {"void"    , {"GtkWindow*"}, {"window"} }, 
    move_focus       = {"void"    , {"GtkWindow*", "GtkDirectionType"}, {"window", "direction"} }, 
    set_focus        = {"void"    , {"GtkWindow*", "GtkWidget*"}, {"window", "focus"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-default'] = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['activate-focus']   = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['frame-event']      = {ret_type = "gboolean", params = {type = {"GtkWindow*", "GdkEvent*"}, name ={"window", "object"}} }, 
    ['keys-changed']     = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['set-focus']        = {ret_type = "void"    , params = {type = {"GtkWindow*", "GtkWidget*"}, name ={"window", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accept_focus        = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_accept_focus((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    allow_grow          = {__type__="gboolean"          ,__default__ = "TRUE"                        ,rwflags="rw" },
    allow_shrink        = {__type__="gboolean"          ,__default__ = "FALSE"                       ,rwflags="rw" },
    decorated           = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_decorated((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    default_height      = {__type__="gint"              ,__default__ = "-1"                          ,rwflags="rw" },
    default_width       = {__type__="gint"              ,__default__ = "-1"                          ,rwflags="rw" },
    deletable           = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_deletable((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    destroy_with_parent = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_destroy_with_parent((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    focus_on_map        = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_focus_on_map((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    gravity             = {__type__="GdkGravity"        ,__default__ = "GDK_GRAVITY_NORTH_WEST"      , __gencode__ = {"gtk_window_set_gravity((GtkWindow*)({* id *}), (GdkGravity)({* property.value *}))"} },
    has_toplevel_focus  = {__type__="gboolean"          ,__default__ = "FALSE"                        },
    icon                = {__type__="GdkPixbuf*"                                                     , __gencode__ = {"gtk_window_set_icon((GtkWindow*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    icon_name           = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_icon_name((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    is_active           = {__type__="gboolean"          ,__default__ = "FALSE"                        },
    mnemonics_visible   = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_mnemonics_visible((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    modal               = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_modal((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    opacity             = {__type__="gdouble"           ,__default__ = "1"                           , __gencode__ = {"gtk_window_set_opacity((GtkWindow*)({* id *}), (gdouble)({* property.value *}))"} },
    resizable           = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_resizable((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    role                = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_role((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    screen              = {__type__="GdkScreen*"                                                     , __gencode__ = {"gtk_window_set_screen((GtkWindow*)({* id *}), (GdkScreen*)({* property.value *}))"} },
    skip_pager_hint     = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_skip_pager_hint((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    skip_taskbar_hint   = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_skip_taskbar_hint((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    startup_id          = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_startup_id((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    title               = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_title((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    transient_for       = {__type__="GtkWindow*"                                                     , __gencode__ = {"gtk_window_set_transient_for((GtkWindow*)({* id *}), (GtkWindow*)({* property.value *}))"},__construct__= 1 },
    type                = {__type__="GtkWindowType"     ,__default__ = "GTK_WINDOW_TOPLEVEL"         ,rwflags="rw" },
    type_hint           = {__type__="GdkWindowTypeHint" ,__default__ = "GDK_WINDOW_TYPE_HINT_NORMAL" , __gencode__ = {"gtk_window_set_type_hint((GtkWindow*)({* id *}), (GdkWindowTypeHint)({* property.value *}))"} },
    urgency_hint        = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_urgency_hint((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    window_position     = {__type__="GtkWindowPosition" ,__default__ = "GTK_WIN_POS_NONE"            ,rwflags="rw" },
  },
  parent = Gtk224.GtkBin,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkAspectFrame
Gtk224.GtkAspectFrame = {
  class = "GtkAspectFrame", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_aspect_frame_new((const gchar*)({* this.label.value *}), (gfloat)({* this.xalign.value *}), (gfloat)({* this.yalign.value *}), (gfloat)({* this.ratio.value *}), (gboolean)({* this.obey_child.value *}))", 
            params = { type = {"const gchar*", "gfloat", "gfloat", "gfloat", "gboolean"}, 
                       name = {"label", "xalign", "yalign", "ratio", "obey_child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    obey_child = {__type__="gboolean" ,__default__ = "TRUE" ,rwflags="rw" },
    ratio      = {__type__="gfloat"   ,__default__ = "1"    ,rwflags="rw" },
    xalign     = {__type__="gfloat"   ,__default__ = "0.5"  ,rwflags="rw" },
    yalign     = {__type__="gfloat"   ,__default__ = "0.5"  ,rwflags="rw" },
  },
  parent = Gtk224.GtkFrame,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkAssistant
Gtk224.GtkAssistant = {
  class = "GtkAssistant", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_assistant_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    apply   = {"void", {"GtkAssistant*"}, {"assistant"} }, 
    cancel  = {"void", {"GtkAssistant*"}, {"assistant"} }, 
    close   = {"void", {"GtkAssistant*"}, {"assistant"} }, 
    prepare = {"void", {"GtkAssistant*", "GtkWidget*"}, {"assistant", "page"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    apply   = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    cancel  = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    close   = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    prepare = {ret_type = "void", params = {type = {"GtkAssistant*", "GtkWidget*"}, name ={"assistant", "page"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    complete      = {__type__="gboolean"             ,__default__ = "FALSE" },
    header_image  = {__type__="GdkPixbuf*"            },
    page_type     = {__type__="GtkAssistantPageType" ,__default__ = "GTK_ASSISTANT_PAGE_CONTENT" },
    sidebar_image = {__type__="GdkPixbuf*"            },
    title         = {__type__="gchar*"               ,__default__ = "NULL" },
  },
  parent = Gtk224.GtkWindow,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkColorButton
Gtk224.GtkColorButton = {
  class = "GtkColorButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_color_button_new()", 
            params = { type = {}, name = {} } },
    new_with_color = { gencode = "gtk_color_button_new_with_color((const GdkColor*)({* this.color.value *}))", 
            params = { type = {"const GdkColor*"}, 
                       name = {"color"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    color_set = {"void", {"GtkColorButton*"}, {"cp"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['color-set'] = {ret_type = "void", params = {type = {"GtkColorButton*"}, name ={"colorbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    alpha     = {__type__="guint"     ,__default__ = "65535"            , __gencode__ = {"gtk_color_button_set_alpha((GtkColorButton*)({* id *}), (guint16)({* property.value *}))"} },
    color     = {__type__="GdkColor*"                                   , __gencode__ = {"gtk_color_button_set_color((GtkColorButton*)({* id *}), (const GdkColor*)({* property.value *}))"} },
    title     = {__type__="gchar*"    ,__default__ = "\"Pick a Color\"" , __gencode__ = {"gtk_color_button_set_title((GtkColorButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    use_alpha = {__type__="gboolean"  ,__default__ = "FALSE"            , __gencode__ = {"gtk_color_button_set_use_alpha((GtkColorButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkColorSelection
Gtk224.GtkColorSelection = {
  class = "GtkColorSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_selection_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    color_changed = {"void", {"GtkColorSelection*"}, {"color_selection"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['color-changed'] = {ret_type = "void", params = {type = {"GtkColorSelection*"}, name ={"colorselection"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    current_alpha       = {__type__="guint"     ,__default__ = "65535" , __gencode__ = {"gtk_color_selection_set_current_alpha((GtkColorSelection*)({* id *}), (guint16)({* property.value *}))"} },
    current_color       = {__type__="GdkColor*"                        , __gencode__ = {"gtk_color_selection_set_current_color((GtkColorSelection*)({* id *}), (const GdkColor*)({* property.value *}))"} },
    has_opacity_control = {__type__="gboolean"  ,__default__ = "FALSE" , __gencode__ = {"gtk_color_selection_set_has_opacity_control((GtkColorSelection*)({* id *}), (gboolean)({* property.value *}))"} },
    has_palette         = {__type__="gboolean"  ,__default__ = "FALSE" , __gencode__ = {"gtk_color_selection_set_has_palette((GtkColorSelection*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkVBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkCombo
Gtk224.GtkCombo = {
  class = "GtkCombo", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_combo_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    allow_empty          = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    case_sensitive       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_combo_set_case_sensitive((GtkCombo*)({* id *}), (gboolean)({* property.value *}))"} },
    enable_arrow_keys    = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    enable_arrows_always = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    value_in_list        = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_combo_set_value_in_list((GtkCombo*)({* id *}), (gboolean)({* property.value *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkHBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkComboBoxEntry
Gtk224.GtkComboBoxEntry = {
  class = "GtkComboBoxEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_combo_box_entry_new()", 
            params = { type = {}, name = {} } },
    new_text       = { gencode = "gtk_combo_box_entry_new_text()", 
            params = { type = {}, name = {} } },
    new_with_model = { gencode = "gtk_combo_box_entry_new_with_model((GtkTreeModel*)({* this.model.value *}), (gint)({* this.text_column.value *}))", 
            params = { type = {"GtkTreeModel*", "gint"}, 
                       name = {"model", "text_column"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    text_column = {__type__="gint" ,__default__ = "-1" , __gencode__ = {"gtk_combo_box_entry_set_text_column((GtkComboBoxEntry*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk224.GtkComboBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellEditable, Gtk224.GtkCellLayout}, 
};

---------------------  GtkComboBoxText
Gtk224.GtkComboBoxText = {
  class = "GtkComboBoxText", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_combo_box_text_new()", 
            params = { type = {}, name = {} } },
    new_with_entry = { gencode = "gtk_combo_box_text_new_with_entry()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkComboBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkCellEditable, Gtk224.GtkCellLayout}, 
};

---------------------  GtkDialog
Gtk224.GtkDialog = {
  class = "GtkDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_dialog_new()", 
            params = { type = {}, name = {} } },
    new_with_buttons = { gencode = "gtk_dialog_new_with_buttons((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    close    = {"void", {"GtkDialog*"}, {"dialog"} }, 
    response = {"void", {"GtkDialog*", "gint"}, {"dialog", "response_id"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close    = {ret_type = "void", params = {type = {"GtkDialog*"}, name ={"dialog"}} }, 
    response = {ret_type = "void", params = {type = {"GtkDialog*", "gint"}, name ={"dialog", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    has_separator = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_dialog_set_has_separator((GtkDialog*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkWindow,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkFileChooserButton
Gtk224.GtkFileChooserButton = {
  class = "GtkFileChooserButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_file_chooser_button_new((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}))", 
            params = { type = {"const gchar*", "GtkFileChooserAction"}, 
                       name = {"title", "action"} } },
    new_with_backend = { gencode = "gtk_file_chooser_button_new_with_backend((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.backend.value *}))", 
            params = { type = {"const gchar*", "GtkFileChooserAction"}, 
                       name = {"title", "action"} } },
    new_with_dialog  = { gencode = "gtk_file_chooser_button_new_with_dialog((GtkWidget*)({* this.dialog.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"dialog"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    file_set = {"void", {"GtkFileChooserButton*"}, {"fc"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['file-set'] = {ret_type = "void", params = {type = {"GtkFileChooserButton*"}, name ={"filechooserbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    dialog         = {__type__="GtkFileChooser*"                                    ,rwflags="w" },
    focus_on_click = {__type__="gboolean"        ,__default__ = "TRUE"              , __gencode__ = {"gtk_file_chooser_button_set_focus_on_click((GtkFileChooserButton*)({* id *}), (gboolean)({* property.value *}))"} },
    title          = {__type__="gchar*"          ,__default__ = "\"Select a File\"" , __gencode__ = {"gtk_file_chooser_button_set_title((GtkFileChooserButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    width_chars    = {__type__="gint"            ,__default__ = "-1"                , __gencode__ = {"gtk_file_chooser_button_set_width_chars((GtkFileChooserButton*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk224.GtkHBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkFileChooser, Gtk224.GtkOrientable}, 
};

---------------------  GtkFileChooserWidget
Gtk224.GtkFileChooserWidget = {
  class = "GtkFileChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_file_chooser_widget_new((GtkFileChooserAction)({* this.action.value *}))", 
            params = { type = {"GtkFileChooserAction"}, 
                       name = {"action"} } },
    new_with_backend = { gencode = "gtk_file_chooser_widget_new_with_backend((GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.backend.value *}))", 
            params = { type = {"GtkFileChooserAction"}, 
                       name = {"action"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkVBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkFileChooser, Gtk224.GtkOrientable}, 
};

---------------------  GtkFontButton
Gtk224.GtkFontButton = {
  class = "GtkFontButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_font_button_new()", 
            params = { type = {}, name = {} } },
    new_with_font = { gencode = "gtk_font_button_new_with_font((const gchar*)({* this.fontname.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    font_set = {"void", {"GtkFontButton*"}, {"gfp"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['font-set'] = {ret_type = "void", params = {type = {"GtkFontButton*"}, name ={"fontbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    font_name  = {__type__="gchar*"   ,__default__ = "\"Sans 12\""     , __gencode__ = {"gtk_font_button_set_font_name((GtkFontButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    show_size  = {__type__="gboolean" ,__default__ = "TRUE"            , __gencode__ = {"gtk_font_button_set_show_size((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    show_style = {__type__="gboolean" ,__default__ = "TRUE"            , __gencode__ = {"gtk_font_button_set_show_style((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    title      = {__type__="gchar*"   ,__default__ = "\"Pick a Font\"" , __gencode__ = {"gtk_font_button_set_title((GtkFontButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    use_font   = {__type__="gboolean" ,__default__ = "FALSE"           , __gencode__ = {"gtk_font_button_set_use_font((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    use_size   = {__type__="gboolean" ,__default__ = "FALSE"           , __gencode__ = {"gtk_font_button_set_use_size((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkFontSelection
Gtk224.GtkFontSelection = {
  class = "GtkFontSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_selection_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    font         = {__type__="GdkFont*"                                               },
    font_name    = {__type__="gchar*"   ,__default__ = "\"Sans 10\""                 , __gencode__ = {"gtk_font_selection_set_font_name((GtkFontSelection*)({* id *}), (const gchar*)({* property.value *}))"} },
    preview_text = {__type__="gchar*"   ,__default__ = "\"abcdefghijk ABCDEFGHIJK\"" , __gencode__ = {"gtk_font_selection_set_preview_text((GtkFontSelection*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkVBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkGammaCurve
Gtk224.GtkGammaCurve = {
  class = "GtkGammaCurve", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gamma_curve_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkVBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkHButtonBox
Gtk224.GtkHButtonBox = {
  class = "GtkHButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hbutton_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkButtonBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkInfoBar
Gtk224.GtkInfoBar = {
  class = "GtkInfoBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_info_bar_new()", 
            params = { type = {}, name = {} } },
    new_with_buttons = { gencode = "gtk_info_bar_new_with_buttons((const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    close    = {"void", {"GtkInfoBar*"}, {"info_bar"} }, 
    response = {"void", {"GtkInfoBar*", "gint"}, {"info_bar", "response_id"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close    = {ret_type = "void", params = {type = {"GtkInfoBar*"}, name ={"info_bar"}} }, 
    response = {ret_type = "void", params = {type = {"GtkInfoBar*", "gint"}, name ={"info_bar", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    message_type = {__type__="GtkMessageType" ,__default__ = "GTK_MESSAGE_INFO" , __gencode__ = {"gtk_info_bar_set_message_type((GtkInfoBar*)({* id *}), (GtkMessageType)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk224.GtkHBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkLinkButton
Gtk224.GtkLinkButton = {
  class = "GtkLinkButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_link_button_new((const gchar*)({* this.uri.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"uri"} } },
    new_with_label = { gencode = "gtk_link_button_new_with_label((const gchar*)({* this.uri.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*", "const gchar*"}, 
                       name = {"uri", "label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    uri     = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_link_button_set_uri((GtkLinkButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    visited = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_link_button_set_visited((GtkLinkButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkListItem
Gtk224.GtkListItem = {
  class = "GtkListItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_list_item_new()", 
            params = { type = {}, name = {} } },
    new_with_label = { gencode = "gtk_list_item_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    end_selection     = {"void", {"GtkListItem*"}, {"list_item"} }, 
    extend_selection  = {"void", {"GtkListItem*", "GtkScrollType", "gfloat", "gboolean"}, {"list_item", "scroll_type", "position", "auto_start_selection"} }, 
    scroll_horizontal = {"void", {"GtkListItem*", "GtkScrollType", "gfloat"}, {"list_item", "scroll_type", "position"} }, 
    scroll_vertical   = {"void", {"GtkListItem*", "GtkScrollType", "gfloat"}, {"list_item", "scroll_type", "position"} }, 
    select_all        = {"void", {"GtkListItem*"}, {"list_item"} }, 
    start_selection   = {"void", {"GtkListItem*"}, {"list_item"} }, 
    toggle_add_mode   = {"void", {"GtkListItem*"}, {"list_item"} }, 
    toggle_focus_row  = {"void", {"GtkListItem*"}, {"list_item"} }, 
    undo_selection    = {"void", {"GtkListItem*"}, {"list_item"} }, 
    unselect_all      = {"void", {"GtkListItem*"}, {"list_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['end-selection']     = {ret_type = "void", params = {type = {"GtkListItem*"}, name ={"listitem"}} }, 
    ['extend-selection']  = {ret_type = "void", params = {type = {"GtkListItem*", "GtkScrollType", "gfloat", "gboolean"}, name ={"listitem", "object", "p0", "p1"}} }, 
    ['scroll-horizontal'] = {ret_type = "void", params = {type = {"GtkListItem*", "GtkScrollType", "gfloat"}, name ={"listitem", "object", "p0"}} }, 
    ['scroll-vertical']   = {ret_type = "void", params = {type = {"GtkListItem*", "GtkScrollType", "gfloat"}, name ={"listitem", "object", "p0"}} }, 
    ['select-all']        = {ret_type = "void", params = {type = {"GtkListItem*"}, name ={"listitem"}} }, 
    ['start-selection']   = {ret_type = "void", params = {type = {"GtkListItem*"}, name ={"listitem"}} }, 
    ['toggle-add-mode']   = {ret_type = "void", params = {type = {"GtkListItem*"}, name ={"listitem"}} }, 
    ['toggle-focus-row']  = {ret_type = "void", params = {type = {"GtkListItem*"}, name ={"listitem"}} }, 
    ['undo-selection']    = {ret_type = "void", params = {type = {"GtkListItem*"}, name ={"listitem"}} }, 
    ['unselect-all']      = {ret_type = "void", params = {type = {"GtkListItem*"}, name ={"listitem"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkItem,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkMenuItem
Gtk224.GtkMenuItem = {
  class = "GtkMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_menu_item_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_menu_item_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_menu_item_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate             = {"void"        , {"GtkMenuItem*"}, {"menu_item"} }, 
    activate_item        = {"void"        , {"GtkMenuItem*"}, {"menu_item"} }, 
    get_label            = {"const gchar*", {"GtkMenuItem*"}, {"menu_item"} }, 
    set_label            = {"void"        , {"GtkMenuItem*", "const gchar*"}, {"menu_item", "label"} }, 
    toggle_size_allocate = {"void"        , {"GtkMenuItem*", "gint"}, {"menu_item", "allocation"} }, 
    toggle_size_request  = {"void"        , {"GtkMenuItem*", "gint*"}, {"menu_item", "requisition"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate                 = {ret_type = "void", params = {type = {"GtkMenuItem*"}, name ={"menu_item"}} }, 
    ['activate-item']        = {ret_type = "void", params = {type = {"GtkMenuItem*"}, name ={"menuitem"}} }, 
    ['toggle-size-allocate'] = {ret_type = "void", params = {type = {"GtkMenuItem*", "gint"}, name ={"menuitem", "object"}} }, 
    ['toggle-size-request']  = {ret_type = "void", params = {type = {"GtkMenuItem*", "gpointer"}, name ={"menuitem", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accel_path      = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_menu_item_set_accel_path((GtkMenuItem*)({* id *}), (const gchar*)({* property.value *}))"} },
    label           = {__type__="gchar*"   ,__default__ = "\"\""  , __gencode__ = {"gtk_menu_item_set_label((GtkMenuItem*)({* id *}), (const gchar*)({* property.value *}))"} },
    right_justified = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_menu_item_set_right_justified((GtkMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
    submenu         = {__type__="GtkMenu*"                        , __gencode__ = {"gtk_menu_item_set_submenu((GtkMenuItem*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    use_underline   = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_menu_item_set_use_underline((GtkMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkOffscreenWindow
Gtk224.GtkOffscreenWindow = {
  class = "GtkOffscreenWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_offscreen_window_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkWindow,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkOptionMenu
Gtk224.GtkOptionMenu = {
  class = "GtkOptionMenu", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_option_menu_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkOptionMenu*"}, {"option_menu"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkOptionMenu*"}, name ={"option_menu"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    menu = {__type__="GtkMenu*" , __gencode__ = {"gtk_option_menu_set_menu((GtkOptionMenu*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkPlug
Gtk224.GtkPlug = {
  class = "GtkPlug", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_plug_new((GdkNativeWindow)({* this.socket_id.value *}))", 
            params = { type = {}, name = {} } },
    new_for_display = { gencode = "gtk_plug_new_for_display((GdkDisplay*)({* this.display.value *}), (GdkNativeWindow)({* this.socket_id.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    embedded = {"void", {"GtkPlug*"}, {"plug"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    embedded = {ret_type = "void", params = {type = {"GtkPlug*"}, name ={"plug"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    embedded      = {__type__="gboolean"   ,__default__ = "FALSE"  },
    socket_window = {__type__="GdkWindow*"                         },
  },
  parent = Gtk224.GtkWindow,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkRecentChooserMenu
Gtk224.GtkRecentChooserMenu = {
  class = "GtkRecentChooserMenu", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_chooser_menu_new()", 
            params = { type = {}, name = {} } },
    new_for_manager = { gencode = "gtk_recent_chooser_menu_new_for_manager((GtkRecentManager*)({* this.manager.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    show_numbers = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_recent_chooser_menu_set_show_numbers((GtkRecentChooserMenu*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkMenu,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable, Gtk224.GtkRecentChooser}, 
};

---------------------  GtkRecentChooserWidget
Gtk224.GtkRecentChooserWidget = {
  class = "GtkRecentChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_chooser_widget_new()", 
            params = { type = {}, name = {} } },
    new_for_manager = { gencode = "gtk_recent_chooser_widget_new_for_manager((GtkRecentManager*)({* this.manager.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkVBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable, Gtk224.GtkRecentChooser}, 
};

---------------------  GtkScaleButton
Gtk224.GtkScaleButton = {
  class = "GtkScaleButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scale_button_new((GtkIconSize)({* this.size.value *}), (gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}), (const gchar**)({* this.icons.value *}))", 
            params = { type = {"GtkIconSize", "const gchar**"}, 
                       name = {"size", "icons"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    value_changed = {"void", {"GtkScaleButton*", "gdouble"}, {"button", "value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    popdown           = {ret_type = "void", params = {type = {"GtkScaleButton*"}, name ={"scalebutton"}} }, 
    popup             = {ret_type = "void", params = {type = {"GtkScaleButton*"}, name ={"scalebutton"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkScaleButton*", "gdouble"}, name ={"scalebutton", "value"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment = {__type__="GtkAdjustment*"                                              , __gencode__ = {"gtk_scale_button_set_adjustment((GtkScaleButton*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    icons      = {__type__="GStrv"                                                       , __gencode__ = {"gtk_scale_button_set_icons((GtkScaleButton*)({* id *}), (const gchar**)({* property.value *}))"} },
    size       = {__type__="GtkIconSize"    ,__default__ = "GTK_ICON_SIZE_SMALL_TOOLBAR" ,rwflags="rw" },
    value      = {__type__="gdouble"        ,__default__ = "0"                           , __gencode__ = {"gtk_scale_button_set_value((GtkScaleButton*)({* id *}), (gdouble)({* property.value *}))"} },
  },
  parent = Gtk224.GtkButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkSeparatorToolItem
Gtk224.GtkSeparatorToolItem = {
  class = "GtkSeparatorToolItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_separator_tool_item_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    draw = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_separator_tool_item_set_draw((GtkSeparatorToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkToolItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkStatusbar
Gtk224.GtkStatusbar = {
  class = "GtkStatusbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_statusbar_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    text_popped = {"void", {"GtkStatusbar*", "guint", "const gchar*"}, {"statusbar", "context_id", "text"} }, 
    text_pushed = {"void", {"GtkStatusbar*", "guint", "const gchar*"}, {"statusbar", "context_id", "text"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['text-popped'] = {ret_type = "void", params = {type = {"GtkStatusbar*", "guint", "gchar*"}, name ={"statusbar", "context_id", "text"}} }, 
    ['text-pushed'] = {ret_type = "void", params = {type = {"GtkStatusbar*", "guint", "gchar*"}, name ={"statusbar", "context_id", "text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    has_resize_grip = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_statusbar_set_has_resize_grip((GtkStatusbar*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkHBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkToggleButton
Gtk224.GtkToggleButton = {
  class = "GtkToggleButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_toggle_button_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_toggle_button_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_toggle_button_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkToggleButton*"}, {"toggle_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkToggleButton*"}, name ={"toggle_button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active         = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_button_set_active((GtkToggleButton*)({* id *}), (gboolean)({* property.value *}))"} },
    draw_indicator = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    inconsistent   = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_button_set_inconsistent((GtkToggleButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkToolButton
Gtk224.GtkToolButton = {
  class = "GtkToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_tool_button_new((GtkWidget*)({* this.icon_widget.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GtkWidget*", "const gchar*"}, 
                       name = {"icon_widget", "label"} } },
    new_from_stock = { gencode = "gtk_tool_button_new_from_stock((const gchar*)({* this.stock_id.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"stock_id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    clicked = {"void", {"GtkToolButton*"}, {"tool_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    clicked = {ret_type = "void", params = {type = {"GtkToolButton*"}, name ={"tool_item"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    icon_name     = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_tool_button_set_icon_name((GtkToolButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    icon_widget   = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_tool_button_set_icon_widget((GtkToolButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    label         = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_tool_button_set_label((GtkToolButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    label_widget  = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_tool_button_set_label_widget((GtkToolButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    stock_id      = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_tool_button_set_stock_id((GtkToolButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    use_underline = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_tool_button_set_use_underline((GtkToolButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkToolItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkVButtonBox
Gtk224.GtkVButtonBox = {
  class = "GtkVButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vbutton_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkButtonBox,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkAboutDialog
Gtk224.GtkAboutDialog = {
  class = "GtkAboutDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_about_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_link = {"gboolean", {"GtkAboutDialog*", "const gchar*"}, {"dialog", "uri"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-link'] = {ret_type = "gboolean", params = {type = {"GtkAboutDialog*", "gchar*"}, name ={"aboutdialog", "uri"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    artists            = {__type__="GStrv"                             , __gencode__ = {"gtk_about_dialog_set_artists((GtkAboutDialog*)({* id *}), (const gchar**)({* property.value *}))"} },
    authors            = {__type__="GStrv"                             , __gencode__ = {"gtk_about_dialog_set_authors((GtkAboutDialog*)({* id *}), (const gchar**)({* property.value *}))"} },
    comments           = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_comments((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    copyright          = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_copyright((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    documenters        = {__type__="GStrv"                             , __gencode__ = {"gtk_about_dialog_set_documenters((GtkAboutDialog*)({* id *}), (const gchar**)({* property.value *}))"} },
    license            = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_license((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    logo               = {__type__="GdkPixbuf*"                        , __gencode__ = {"gtk_about_dialog_set_logo((GtkAboutDialog*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    logo_icon_name     = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_logo_icon_name((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    program_name       = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_program_name((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    translator_credits = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_translator_credits((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    version            = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_version((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    website            = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_website((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    website_label      = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_about_dialog_set_website_label((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    wrap_license       = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_about_dialog_set_wrap_license((GtkAboutDialog*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkCheckButton
Gtk224.GtkCheckButton = {
  class = "GtkCheckButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_check_button_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_check_button_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_check_button_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    draw_indicator = {"void", {"GtkCheckButton*", "GdkRectangle*"}, {"check_button", "area"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkToggleButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkCheckMenuItem
Gtk224.GtkCheckMenuItem = {
  class = "GtkCheckMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_check_menu_item_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_check_menu_item_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_check_menu_item_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    draw_indicator = {"void", {"GtkCheckMenuItem*", "GdkRectangle*"}, {"check_menu_item", "area"} }, 
    toggled        = {"void", {"GtkCheckMenuItem*"}, {"check_menu_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkCheckMenuItem*"}, name ={"check_menu_item"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active        = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_check_menu_item_set_active((GtkCheckMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
    draw_as_radio = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_check_menu_item_set_draw_as_radio((GtkCheckMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
    inconsistent  = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_check_menu_item_set_inconsistent((GtkCheckMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkMenuItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkColorSelectionDialog
Gtk224.GtkColorSelectionDialog = {
  class = "GtkColorSelectionDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_selection_dialog_new((const gchar*)({* this.title.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"title"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    cancel_button   = {__type__="GtkWidget*"  },
    color_selection = {__type__="GtkWidget*"  },
    help_button     = {__type__="GtkWidget*"  },
    ok_button       = {__type__="GtkWidget*"  },
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkFileChooserDialog
Gtk224.GtkFileChooserDialog = {
  class = "GtkFileChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_file_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*", "GtkFileChooserAction"}, 
                       name = {"title", "parent", "action"} } },
    new_with_backend = { gencode = "gtk_file_chooser_dialog_new_with_backend((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.backend.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*", "GtkFileChooserAction"}, 
                       name = {"title", "parent", "action"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkFileChooser}, 
};

---------------------  GtkFileSelection
Gtk224.GtkFileSelection = {
  class = "GtkFileSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_selection_new((const gchar*)({* this.title.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"title"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filename        = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_file_selection_set_filename((GtkFileSelection*)({* id *}), (const gchar*)({* property.value *}))"} },
    select_multiple = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_file_selection_set_select_multiple((GtkFileSelection*)({* id *}), (gboolean)({* property.value *}))"} },
    show_fileops    = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkFontSelectionDialog
Gtk224.GtkFontSelectionDialog = {
  class = "GtkFontSelectionDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_selection_dialog_new((const gchar*)({* this.title.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"title"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkImageMenuItem
Gtk224.GtkImageMenuItem = {
  class = "GtkImageMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_image_menu_item_new()", 
            params = { type = {}, name = {} } },
    new_from_stock    = { gencode = "gtk_image_menu_item_new_from_stock((const gchar*)({* this.stock_id.value *}), (GtkAccelGroup*)({* this.accel_group.value *}))", 
            params = { type = {"GtkAccelGroup*"}, 
                       name = {"accel_group"} } },
    new_with_label    = { gencode = "gtk_image_menu_item_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_image_menu_item_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accel_group       = {__type__="GtkAccelGroup*"                        , __gencode__ = {"gtk_image_menu_item_set_accel_group((GtkImageMenuItem*)({* id *}), (GtkAccelGroup*)({* property.value *}))"} },
    always_show_image = {__type__="gboolean"       ,__default__ = "FALSE" , __gencode__ = {"gtk_image_menu_item_set_always_show_image((GtkImageMenuItem*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    image             = {__type__="GtkWidget*"                            , __gencode__ = {"gtk_image_menu_item_set_image((GtkImageMenuItem*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    use_stock         = {__type__="gboolean"       ,__default__ = "FALSE" , __gencode__ = {"gtk_image_menu_item_set_use_stock((GtkImageMenuItem*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk224.GtkMenuItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkInputDialog
Gtk224.GtkInputDialog = {
  class = "GtkInputDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_input_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    disable_device = {"void", {"GtkInputDialog*", "GdkDevice*"}, {"inputd", "device"} }, 
    enable_device  = {"void", {"GtkInputDialog*", "GdkDevice*"}, {"inputd", "device"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['disable-device'] = {ret_type = "void", params = {type = {"GtkInputDialog*", "GdkDevice*"}, name ={"inputdialog", "object"}} }, 
    ['enable-device']  = {ret_type = "void", params = {type = {"GtkInputDialog*", "GdkDevice*"}, name ={"inputdialog", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkMenuToolButton
Gtk224.GtkMenuToolButton = {
  class = "GtkMenuToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_menu_tool_button_new((GtkWidget*)({* this.icon_widget.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GtkWidget*", "const gchar*"}, 
                       name = {"icon_widget", "label"} } },
    new_from_stock = { gencode = "gtk_menu_tool_button_new_from_stock((const gchar*)({* this.stock_id.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"stock_id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    show_menu = {"void", {"GtkMenuToolButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['show-menu'] = {ret_type = "void", params = {type = {"GtkMenuToolButton*"}, name ={"menutoolbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    menu = {__type__="GtkMenu*" , __gencode__ = {"gtk_menu_tool_button_set_menu((GtkMenuToolButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkToolButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkMessageDialog
Gtk224.GtkMessageDialog = {
  class = "GtkMessageDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_message_dialog_new((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GtkMessageType)({* this.type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.message_format.value *}), 0)", 
            params = { type = {"GtkWindow*", "GtkMessageType", "GtkButtonsType"}, 
                       name = {"parent", "type", "buttons"} } },
    new_with_markup = { gencode = "gtk_message_dialog_new_with_markup((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GtkMessageType)({* this.type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.message_format.value *}), 0)", 
            params = { type = {"GtkWindow*", "GtkMessageType", "GtkButtonsType"}, 
                       name = {"parent", "type", "buttons"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    buttons              = {__type__="GtkButtonsType" ,__default__ = "GTK_BUTTONS_NONE" ,rwflags="w" },
    image                = {__type__="GtkWidget*"                                       , __gencode__ = {"gtk_message_dialog_set_image((GtkMessageDialog*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    message_area         = {__type__="GtkWidget*"                                        },
    message_type         = {__type__="GtkMessageType" ,__default__ = "GTK_MESSAGE_INFO" ,rwflags="rw",__construct__= 1 },
    secondary_text       = {__type__="gchar*"         ,__default__ = "NULL"             ,rwflags="rw" },
    secondary_use_markup = {__type__="gboolean"       ,__default__ = "FALSE"            ,rwflags="rw" },
    text                 = {__type__="gchar*"         ,__default__ = "\"\""             ,rwflags="rw" },
    use_markup           = {__type__="gboolean"       ,__default__ = "FALSE"            ,rwflags="rw" },
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
};

---------------------  GtkRecentChooserDialog
Gtk224.GtkRecentChooserDialog = {
  class = "GtkRecentChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
    new_for_manager = { gencode = "gtk_recent_chooser_dialog_new_for_manager((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkRecentManager*)({* this.manager.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable, Gtk224.GtkRecentChooser}, 
};

---------------------  GtkSeparatorMenuItem
Gtk224.GtkSeparatorMenuItem = {
  class = "GtkSeparatorMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_separator_menu_item_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkMenuItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkTearoffMenuItem
Gtk224.GtkTearoffMenuItem = {
  class = "GtkTearoffMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tearoff_menu_item_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkMenuItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkToggleToolButton
Gtk224.GtkToggleToolButton = {
  class = "GtkToggleToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_toggle_tool_button_new()", 
            params = { type = {}, name = {} } },
    new_from_stock = { gencode = "gtk_toggle_tool_button_new_from_stock((const gchar*)({* this.stock_id.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"stock_id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkToggleToolButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkToggleToolButton*"}, name ={"button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_tool_button_set_active((GtkToggleToolButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk224.GtkToolButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkVolumeButton
Gtk224.GtkVolumeButton = {
  class = "GtkVolumeButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_volume_button_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkScaleButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable, Gtk224.GtkOrientable}, 
};

---------------------  GtkRadioButton
Gtk224.GtkRadioButton = {
  class = "GtkRadioButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new                           = { gencode = "gtk_radio_button_new((GSList*)({* this.group.value *}))", 
            params = { type = {"GSList*"}, 
                       name = {"group"} } },
    new_with_label                = { gencode = "gtk_radio_button_new_with_label((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_label_from_widget    = { gencode = "gtk_radio_button_new_with_label_from_widget((GtkRadioButton*)({* this.radio_group_member.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic             = { gencode = "gtk_radio_button_new_with_mnemonic((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_mnemonic_from_widget = { gencode = "gtk_radio_button_new_with_mnemonic_from_widget((GtkRadioButton*)({* this.radio_group_member.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    group_changed = {"void", {"GtkRadioButton*"}, {"radio_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['group-changed'] = {ret_type = "void", params = {type = {"GtkRadioButton*"}, name ={"radiobutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    group = {__type__="GtkRadioButton*" , __gencode__ = {"gtk_radio_button_set_group((GtkRadioButton*)({* id *}), (GSList*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkCheckButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkRadioMenuItem
Gtk224.GtkRadioMenuItem = {
  class = "GtkRadioMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_radio_menu_item_new((GSList*)({* this.group.value *}))", 
            params = { type = {"GSList*"}, 
                       name = {"group"} } },
    new_with_label    = { gencode = "gtk_radio_menu_item_new_with_label((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_mnemonic = { gencode = "gtk_radio_menu_item_new_with_mnemonic((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    group_changed = {"void", {"GtkRadioMenuItem*"}, {"radio_menu_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['group-changed'] = {ret_type = "void", params = {type = {"GtkRadioMenuItem*"}, name ={"radiomenuitem"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    group = {__type__="GtkRadioMenuItem*" , __gencode__ = {"gtk_radio_menu_item_set_group((GtkRadioMenuItem*)({* id *}), (GSList*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkCheckMenuItem,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

---------------------  GtkRadioToolButton
Gtk224.GtkRadioToolButton = {
  class = "GtkRadioToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_radio_tool_button_new((GSList*)({* this.group.value *}))", 
            params = { type = {"GSList*"}, 
                       name = {"group"} } },
    new_from_stock = { gencode = "gtk_radio_tool_button_new_from_stock((GSList*)({* this.group.value *}), (const gchar*)({* this.stock_id.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "stock_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    group = {__type__="GtkRadioToolButton*" , __gencode__ = {"gtk_radio_tool_button_set_group((GtkRadioToolButton*)({* id *}), (GSList*)({* property.value *}))"} },
  },
  parent = Gtk224.GtkToggleToolButton,
  implement = {Gtk224.GtkActivatable, Gtk224.GtkBuildable}, 
};

----  [Gtk Classes] End ... 
----  [Gtk Enumerates] Start ... 
Gtk224.GtkEnumerationes = Gtk224.GtkEnumerationes or {}
do
    local merge_list = function (old_list)
        if Gtk224.GtkEnumerationes == nil then
            return old_list
        end
        for i, v in pairs(Gtk224.GtkEnumerationes) do
            old_list[i] = v
        end
        return old_list
    end
    Gtk224.GtkEnumerationes = merge_list({
        GtkAnchorType = {
        { macro = 'GTK_ANCHOR_CENTER'    , name = "center",     nick = "center",     value = "0"}, 
        { macro = 'GTK_ANCHOR_E'         , name = "e",          nick = "e",          value = "8"}, 
        { macro = 'GTK_ANCHOR_EAST'      , name = "east",       nick = "east",       value = "8"}, 
        { macro = 'GTK_ANCHOR_N'         , name = "n",          nick = "n",          value = "1"}, 
        { macro = 'GTK_ANCHOR_NE'        , name = "ne",         nick = "ne",         value = "3"}, 
        { macro = 'GTK_ANCHOR_NORTH'     , name = "north",      nick = "north",      value = "1"}, 
        { macro = 'GTK_ANCHOR_NORTH_EAST', name = "north_east", nick = "north-east", value = "3"}, 
        { macro = 'GTK_ANCHOR_NORTH_WEST', name = "north_west", nick = "north-west", value = "2"}, 
        { macro = 'GTK_ANCHOR_NW'        , name = "nw",         nick = "nw",         value = "2"}, 
        { macro = 'GTK_ANCHOR_S'         , name = "s",          nick = "s",          value = "4"}, 
        { macro = 'GTK_ANCHOR_SE'        , name = "se",         nick = "se",         value = "6"}, 
        { macro = 'GTK_ANCHOR_SOUTH'     , name = "south",      nick = "south",      value = "4"}, 
        { macro = 'GTK_ANCHOR_SOUTH_EAST', name = "south_east", nick = "south-east", value = "6"}, 
        { macro = 'GTK_ANCHOR_SOUTH_WEST', name = "south_west", nick = "south-west", value = "5"}, 
        { macro = 'GTK_ANCHOR_SW'        , name = "sw",         nick = "sw",         value = "5"}, 
        { macro = 'GTK_ANCHOR_W'         , name = "w",          nick = "w",          value = "7"}, 
        { macro = 'GTK_ANCHOR_WEST'      , name = "west",       nick = "west",       value = "7"}, 
    },
    GtkArrowPlacement = {
        { macro = 'GTK_ARROWS_BOTH' , name = "both",  nick = "both",  value = "0"}, 
        { macro = 'GTK_ARROWS_END'  , name = "end",   nick = "end",   value = "2"}, 
        { macro = 'GTK_ARROWS_START', name = "start", nick = "start", value = "1"}, 
    },
    GtkArrowType = {
        { macro = 'GTK_ARROW_DOWN' , name = "down",  nick = "down",  value = "1"}, 
        { macro = 'GTK_ARROW_LEFT' , name = "left",  nick = "left",  value = "2"}, 
        { macro = 'GTK_ARROW_NONE' , name = "none",  nick = "none",  value = "4"}, 
        { macro = 'GTK_ARROW_RIGHT', name = "right", nick = "right", value = "3"}, 
        { macro = 'GTK_ARROW_UP'   , name = "up",    nick = "up",    value = "0"}, 
    },
    GtkAssistantPageType = {
        { macro = 'GTK_ASSISTANT_PAGE_CONFIRM' , name = "confirm",  nick = "confirm",  value = "2"}, 
        { macro = 'GTK_ASSISTANT_PAGE_CONTENT' , name = "content",  nick = "content",  value = "0"}, 
        { macro = 'GTK_ASSISTANT_PAGE_INTRO'   , name = "intro",    nick = "intro",    value = "1"}, 
        { macro = 'GTK_ASSISTANT_PAGE_PROGRESS', name = "progress", nick = "progress", value = "4"}, 
        { macro = 'GTK_ASSISTANT_PAGE_SUMMARY' , name = "summary",  nick = "summary",  value = "3"}, 
    },
    GtkBuilderError = {
        { macro = 'GTK_BUILDER_ERROR_DUPLICATE_ID'          , name = "duplicate_id",           nick = "duplicate-id",           value = "8"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_ATTRIBUTE'     , name = "invalid_attribute",      nick = "invalid-attribute",      value = "3"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_TAG'           , name = "invalid_tag",            nick = "invalid-tag",            value = "4"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION' , name = "invalid_type_function",  nick = "invalid-type-function",  value = "0"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_VALUE'         , name = "invalid_value",          nick = "invalid-value",          value = "6"}, 
        { macro = 'GTK_BUILDER_ERROR_MISSING_ATTRIBUTE'     , name = "missing_attribute",      nick = "missing-attribute",      value = "2"}, 
        { macro = 'GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE', name = "missing_property_value", nick = "missing-property-value", value = "5"}, 
        { macro = 'GTK_BUILDER_ERROR_UNHANDLED_TAG'         , name = "unhandled_tag",          nick = "unhandled-tag",          value = "1"}, 
        { macro = 'GTK_BUILDER_ERROR_VERSION_MISMATCH'      , name = "version_mismatch",       nick = "version-mismatch",       value = "7"}, 
    },
    GtkButtonBoxStyle = {
        { macro = 'GTK_BUTTONBOX_CENTER'       , name = "center",        nick = "center",        value = "5"}, 
        { macro = 'GTK_BUTTONBOX_DEFAULT_STYLE', name = "default_style", nick = "default-style", value = "0"}, 
        { macro = 'GTK_BUTTONBOX_EDGE'         , name = "edge",          nick = "edge",          value = "2"}, 
        { macro = 'GTK_BUTTONBOX_END'          , name = "end",           nick = "end",           value = "4"}, 
        { macro = 'GTK_BUTTONBOX_SPREAD'       , name = "spread",        nick = "spread",        value = "1"}, 
        { macro = 'GTK_BUTTONBOX_START'        , name = "start",         nick = "start",         value = "3"}, 
    },
    GtkButtonsType = {
        { macro = 'GTK_BUTTONS_CANCEL'   , name = "cancel",    nick = "cancel",    value = "3"}, 
        { macro = 'GTK_BUTTONS_CLOSE'    , name = "close",     nick = "close",     value = "2"}, 
        { macro = 'GTK_BUTTONS_NONE'     , name = "none",      nick = "none",      value = "0"}, 
        { macro = 'GTK_BUTTONS_OK'       , name = "ok",        nick = "ok",        value = "1"}, 
        { macro = 'GTK_BUTTONS_OK_CANCEL', name = "ok_cancel", nick = "ok-cancel", value = "5"}, 
        { macro = 'GTK_BUTTONS_YES_NO'   , name = "yes_no",    nick = "yes-no",    value = "4"}, 
    },
    GtkCListDragPos = {
        { macro = 'GTK_CLIST_DRAG_AFTER' , name = "after",  nick = "after",  value = "3"}, 
        { macro = 'GTK_CLIST_DRAG_BEFORE', name = "before", nick = "before", value = "1"}, 
        { macro = 'GTK_CLIST_DRAG_INTO'  , name = "into",   nick = "into",   value = "2"}, 
        { macro = 'GTK_CLIST_DRAG_NONE'  , name = "none",   nick = "none",   value = "0"}, 
    },
    GtkCTreeExpanderStyle = {
        { macro = 'GTK_CTREE_EXPANDER_CIRCULAR', name = "circular", nick = "circular", value = "3"}, 
        { macro = 'GTK_CTREE_EXPANDER_NONE'    , name = "none",     nick = "none",     value = "0"}, 
        { macro = 'GTK_CTREE_EXPANDER_SQUARE'  , name = "square",   nick = "square",   value = "1"}, 
        { macro = 'GTK_CTREE_EXPANDER_TRIANGLE', name = "triangle", nick = "triangle", value = "2"}, 
    },
    GtkCTreeExpansionType = {
        { macro = 'GTK_CTREE_EXPANSION_COLLAPSE'          , name = "collapse",           nick = "collapse",           value = "2"}, 
        { macro = 'GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE', name = "collapse_recursive", nick = "collapse-recursive", value = "3"}, 
        { macro = 'GTK_CTREE_EXPANSION_EXPAND'            , name = "expand",             nick = "expand",             value = "0"}, 
        { macro = 'GTK_CTREE_EXPANSION_EXPAND_RECURSIVE'  , name = "expand_recursive",   nick = "expand-recursive",   value = "1"}, 
        { macro = 'GTK_CTREE_EXPANSION_TOGGLE'            , name = "toggle",             nick = "toggle",             value = "4"}, 
        { macro = 'GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE'  , name = "toggle_recursive",   nick = "toggle-recursive",   value = "5"}, 
    },
    GtkCTreeLineStyle = {
        { macro = 'GTK_CTREE_LINES_DOTTED', name = "dotted", nick = "dotted", value = "2"}, 
        { macro = 'GTK_CTREE_LINES_NONE'  , name = "none",   nick = "none",   value = "0"}, 
        { macro = 'GTK_CTREE_LINES_SOLID' , name = "solid",  nick = "solid",  value = "1"}, 
        { macro = 'GTK_CTREE_LINES_TABBED', name = "tabbed", nick = "tabbed", value = "3"}, 
    },
    GtkCTreePos = {
        { macro = 'GTK_CTREE_POS_AFTER'   , name = "after",    nick = "after",    value = "2"}, 
        { macro = 'GTK_CTREE_POS_AS_CHILD', name = "as_child", nick = "as-child", value = "1"}, 
        { macro = 'GTK_CTREE_POS_BEFORE'  , name = "before",   nick = "before",   value = "0"}, 
    },
    GtkCellRendererAccelMode = {
        { macro = 'GTK_CELL_RENDERER_ACCEL_MODE_GTK'  , name = "gtk",   nick = "gtk",   value = "0"}, 
        { macro = 'GTK_CELL_RENDERER_ACCEL_MODE_OTHER', name = "other", nick = "other", value = "1"}, 
    },
    GtkCellRendererMode = {
        { macro = 'GTK_CELL_RENDERER_MODE_ACTIVATABLE', name = "activatable", nick = "activatable", value = "1"}, 
        { macro = 'GTK_CELL_RENDERER_MODE_EDITABLE'   , name = "editable",    nick = "editable",    value = "2"}, 
        { macro = 'GTK_CELL_RENDERER_MODE_INERT'      , name = "inert",       nick = "inert",       value = "0"}, 
    },
    GtkCellType = {
        { macro = 'GTK_CELL_EMPTY'  , name = "empty",   nick = "empty",   value = "0"}, 
        { macro = 'GTK_CELL_PIXMAP' , name = "pixmap",  nick = "pixmap",  value = "2"}, 
        { macro = 'GTK_CELL_PIXTEXT', name = "pixtext", nick = "pixtext", value = "3"}, 
        { macro = 'GTK_CELL_TEXT'   , name = "text",    nick = "text",    value = "1"}, 
        { macro = 'GTK_CELL_WIDGET' , name = "widget",  nick = "widget",  value = "4"}, 
    },
    GtkCornerType = {
        { macro = 'GTK_CORNER_BOTTOM_LEFT' , name = "bottom_left",  nick = "bottom-left",  value = "1"}, 
        { macro = 'GTK_CORNER_BOTTOM_RIGHT', name = "bottom_right", nick = "bottom-right", value = "3"}, 
        { macro = 'GTK_CORNER_TOP_LEFT'    , name = "top_left",     nick = "top-left",     value = "0"}, 
        { macro = 'GTK_CORNER_TOP_RIGHT'   , name = "top_right",    nick = "top-right",    value = "2"}, 
    },
    GtkCurveType = {
        { macro = 'GTK_CURVE_TYPE_FREE'  , name = "free",   nick = "free",   value = "2"}, 
        { macro = 'GTK_CURVE_TYPE_LINEAR', name = "linear", nick = "linear", value = "0"}, 
        { macro = 'GTK_CURVE_TYPE_SPLINE', name = "spline", nick = "spline", value = "1"}, 
    },
    GtkDeleteType = {
        { macro = 'GTK_DELETE_CHARS'            , name = "chars",             nick = "chars",             value = "0"}, 
        { macro = 'GTK_DELETE_DISPLAY_LINE_ENDS', name = "display_line_ends", nick = "display-line-ends", value = "4"}, 
        { macro = 'GTK_DELETE_DISPLAY_LINES'    , name = "display_lines",     nick = "display-lines",     value = "3"}, 
        { macro = 'GTK_DELETE_PARAGRAPH_ENDS'   , name = "paragraph_ends",    nick = "paragraph-ends",    value = "5"}, 
        { macro = 'GTK_DELETE_PARAGRAPHS'       , name = "paragraphs",        nick = "paragraphs",        value = "6"}, 
        { macro = 'GTK_DELETE_WHITESPACE'       , name = "whitespace",        nick = "whitespace",        value = "7"}, 
        { macro = 'GTK_DELETE_WORD_ENDS'        , name = "word_ends",         nick = "word-ends",         value = "1"}, 
        { macro = 'GTK_DELETE_WORDS'            , name = "words",             nick = "words",             value = "2"}, 
    },
    GtkDirectionType = {
        { macro = 'GTK_DIR_DOWN'        , name = "down",         nick = "down",         value = "3"}, 
        { macro = 'GTK_DIR_LEFT'        , name = "left",         nick = "left",         value = "4"}, 
        { macro = 'GTK_DIR_RIGHT'       , name = "right",        nick = "right",        value = "5"}, 
        { macro = 'GTK_DIR_TAB_BACKWARD', name = "tab_backward", nick = "tab-backward", value = "1"}, 
        { macro = 'GTK_DIR_TAB_FORWARD' , name = "tab_forward",  nick = "tab-forward",  value = "0"}, 
        { macro = 'GTK_DIR_UP'          , name = "up",           nick = "up",           value = "2"}, 
    },
    GtkDragResult = {
        { macro = 'GTK_DRAG_RESULT_ERROR'          , name = "error",           nick = "error",           value = "5"}, 
        { macro = 'GTK_DRAG_RESULT_GRAB_BROKEN'    , name = "grab_broken",     nick = "grab-broken",     value = "4"}, 
        { macro = 'GTK_DRAG_RESULT_NO_TARGET'      , name = "no_target",       nick = "no-target",       value = "1"}, 
        { macro = 'GTK_DRAG_RESULT_SUCCESS'        , name = "success",         nick = "success",         value = "0"}, 
        { macro = 'GTK_DRAG_RESULT_TIMEOUT_EXPIRED', name = "timeout_expired", nick = "timeout-expired", value = "3"}, 
        { macro = 'GTK_DRAG_RESULT_USER_CANCELLED' , name = "user_cancelled",  nick = "user-cancelled",  value = "2"}, 
    },
    GtkEntryIconPosition = {
        { macro = 'GTK_ENTRY_ICON_PRIMARY'  , name = "primary",   nick = "primary",   value = "0"}, 
        { macro = 'GTK_ENTRY_ICON_SECONDARY', name = "secondary", nick = "secondary", value = "1"}, 
    },
    GtkExpanderStyle = {
        { macro = 'GTK_EXPANDER_COLLAPSED'     , name = "collapsed",      nick = "collapsed",      value = "0"}, 
        { macro = 'GTK_EXPANDER_EXPANDED'      , name = "expanded",       nick = "expanded",       value = "3"}, 
        { macro = 'GTK_EXPANDER_SEMI_COLLAPSED', name = "semi_collapsed", nick = "semi-collapsed", value = "1"}, 
        { macro = 'GTK_EXPANDER_SEMI_EXPANDED' , name = "semi_expanded",  nick = "semi-expanded",  value = "2"}, 
    },
    GtkFileChooserAction = {
        { macro = 'GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER', name = "create_folder", nick = "create-folder", value = "3"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_OPEN'         , name = "open",          nick = "open",          value = "0"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_SAVE'         , name = "save",          nick = "save",          value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER', name = "select_folder", nick = "select-folder", value = "2"}, 
    },
    GtkFileChooserConfirmation = {
        { macro = 'GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME', name = "accept_filename", nick = "accept-filename", value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM'        , name = "confirm",         nick = "confirm",         value = "0"}, 
        { macro = 'GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN'   , name = "select_again",    nick = "select-again",    value = "2"}, 
    },
    GtkFileChooserError = {
        { macro = 'GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS'     , name = "already_exists",      nick = "already-exists",      value = "2"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_BAD_FILENAME'       , name = "bad_filename",        nick = "bad-filename",        value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME', name = "incomplete_hostname", nick = "incomplete-hostname", value = "3"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_NONEXISTENT'        , name = "nonexistent",         nick = "nonexistent",         value = "0"}, 
    },
    GtkIMPreeditStyle = {
        { macro = 'GTK_IM_PREEDIT_CALLBACK', name = "callback", nick = "callback", value = "1"}, 
        { macro = 'GTK_IM_PREEDIT_NONE'    , name = "none",     nick = "none",     value = "2"}, 
        { macro = 'GTK_IM_PREEDIT_NOTHING' , name = "nothing",  nick = "nothing",  value = "0"}, 
    },
    GtkIMStatusStyle = {
        { macro = 'GTK_IM_STATUS_CALLBACK', name = "callback", nick = "callback", value = "1"}, 
        { macro = 'GTK_IM_STATUS_NONE'    , name = "none",     nick = "none",     value = "2"}, 
        { macro = 'GTK_IM_STATUS_NOTHING' , name = "nothing",  nick = "nothing",  value = "0"}, 
    },
    GtkIconSize = {
        { macro = 'GTK_ICON_SIZE_BUTTON'       , name = "button",        nick = "button",        value = "4"}, 
        { macro = 'GTK_ICON_SIZE_DIALOG'       , name = "dialog",        nick = "dialog",        value = "6"}, 
        { macro = 'GTK_ICON_SIZE_DND'          , name = "dnd",           nick = "dnd",           value = "5"}, 
        { macro = 'GTK_ICON_SIZE_INVALID'      , name = "invalid",       nick = "invalid",       value = "0"}, 
        { macro = 'GTK_ICON_SIZE_LARGE_TOOLBAR', name = "large_toolbar", nick = "large-toolbar", value = "3"}, 
        { macro = 'GTK_ICON_SIZE_MENU'         , name = "menu",          nick = "menu",          value = "1"}, 
        { macro = 'GTK_ICON_SIZE_SMALL_TOOLBAR', name = "small_toolbar", nick = "small-toolbar", value = "2"}, 
    },
    GtkIconThemeError = {
        { macro = 'GTK_ICON_THEME_FAILED'   , name = "failed",    nick = "failed",    value = "1"}, 
        { macro = 'GTK_ICON_THEME_NOT_FOUND', name = "not_found", nick = "not-found", value = "0"}, 
    },
    GtkIconViewDropPosition = {
        { macro = 'GTK_ICON_VIEW_DROP_ABOVE', name = "drop_above", nick = "drop-above", value = "4"}, 
        { macro = 'GTK_ICON_VIEW_DROP_BELOW', name = "drop_below", nick = "drop-below", value = "5"}, 
        { macro = 'GTK_ICON_VIEW_DROP_INTO' , name = "drop_into",  nick = "drop-into",  value = "1"}, 
        { macro = 'GTK_ICON_VIEW_DROP_LEFT' , name = "drop_left",  nick = "drop-left",  value = "2"}, 
        { macro = 'GTK_ICON_VIEW_DROP_RIGHT', name = "drop_right", nick = "drop-right", value = "3"}, 
        { macro = 'GTK_ICON_VIEW_NO_DROP'   , name = "no_drop",    nick = "no-drop",    value = "0"}, 
    },
    GtkImageType = {
        { macro = 'GTK_IMAGE_ANIMATION', name = "animation", nick = "animation", value = "6"}, 
        { macro = 'GTK_IMAGE_EMPTY'    , name = "empty",     nick = "empty",     value = "0"}, 
        { macro = 'GTK_IMAGE_GICON'    , name = "gicon",     nick = "gicon",     value = "8"}, 
        { macro = 'GTK_IMAGE_ICON_NAME', name = "icon_name", nick = "icon-name", value = "7"}, 
        { macro = 'GTK_IMAGE_ICON_SET' , name = "icon_set",  nick = "icon-set",  value = "5"}, 
        { macro = 'GTK_IMAGE_IMAGE'    , name = "image",     nick = "image",     value = "2"}, 
        { macro = 'GTK_IMAGE_PIXBUF'   , name = "pixbuf",    nick = "pixbuf",    value = "3"}, 
        { macro = 'GTK_IMAGE_PIXMAP'   , name = "pixmap",    nick = "pixmap",    value = "1"}, 
        { macro = 'GTK_IMAGE_STOCK'    , name = "stock",     nick = "stock",     value = "4"}, 
    },
    GtkJustification = {
        { macro = 'GTK_JUSTIFY_CENTER', name = "center", nick = "center", value = "2"}, 
        { macro = 'GTK_JUSTIFY_FILL'  , name = "fill",   nick = "fill",   value = "3"}, 
        { macro = 'GTK_JUSTIFY_LEFT'  , name = "left",   nick = "left",   value = "0"}, 
        { macro = 'GTK_JUSTIFY_RIGHT' , name = "right",  nick = "right",  value = "1"}, 
    },
    GtkMatchType = {
        { macro = 'GTK_MATCH_ALL'     , name = "all",      nick = "all",      value = "0"}, 
        { macro = 'GTK_MATCH_ALL_TAIL', name = "all_tail", nick = "all-tail", value = "1"}, 
        { macro = 'GTK_MATCH_EXACT'   , name = "exact",    nick = "exact",    value = "4"}, 
        { macro = 'GTK_MATCH_HEAD'    , name = "head",     nick = "head",     value = "2"}, 
        { macro = 'GTK_MATCH_LAST'    , name = "last",     nick = "last",     value = "5"}, 
        { macro = 'GTK_MATCH_TAIL'    , name = "tail",     nick = "tail",     value = "3"}, 
    },
    GtkMenuDirectionType = {
        { macro = 'GTK_MENU_DIR_CHILD' , name = "child",  nick = "child",  value = "1"}, 
        { macro = 'GTK_MENU_DIR_NEXT'  , name = "next",   nick = "next",   value = "2"}, 
        { macro = 'GTK_MENU_DIR_PARENT', name = "parent", nick = "parent", value = "0"}, 
        { macro = 'GTK_MENU_DIR_PREV'  , name = "prev",   nick = "prev",   value = "3"}, 
    },
    GtkMessageType = {
        { macro = 'GTK_MESSAGE_ERROR'   , name = "error",    nick = "error",    value = "3"}, 
        { macro = 'GTK_MESSAGE_INFO'    , name = "info",     nick = "info",     value = "0"}, 
        { macro = 'GTK_MESSAGE_OTHER'   , name = "other",    nick = "other",    value = "4"}, 
        { macro = 'GTK_MESSAGE_QUESTION', name = "question", nick = "question", value = "2"}, 
        { macro = 'GTK_MESSAGE_WARNING' , name = "warning",  nick = "warning",  value = "1"}, 
    },
    GtkMetricType = {
        { macro = 'GTK_CENTIMETERS', name = "centimeters", nick = "centimeters", value = "2"}, 
        { macro = 'GTK_INCHES'     , name = "inches",      nick = "inches",      value = "1"}, 
        { macro = 'GTK_PIXELS'     , name = "pixels",      nick = "pixels",      value = "0"}, 
    },
    GtkMovementStep = {
        { macro = 'GTK_MOVEMENT_BUFFER_ENDS'      , name = "buffer_ends",       nick = "buffer-ends",       value = "8"}, 
        { macro = 'GTK_MOVEMENT_DISPLAY_LINE_ENDS', name = "display_line_ends", nick = "display-line-ends", value = "4"}, 
        { macro = 'GTK_MOVEMENT_DISPLAY_LINES'    , name = "display_lines",     nick = "display-lines",     value = "3"}, 
        { macro = 'GTK_MOVEMENT_HORIZONTAL_PAGES' , name = "horizontal_pages",  nick = "horizontal-pages",  value = "9"}, 
        { macro = 'GTK_MOVEMENT_LOGICAL_POSITIONS', name = "logical_positions", nick = "logical-positions", value = "0"}, 
        { macro = 'GTK_MOVEMENT_PAGES'            , name = "pages",             nick = "pages",             value = "7"}, 
        { macro = 'GTK_MOVEMENT_PARAGRAPH_ENDS'   , name = "paragraph_ends",    nick = "paragraph-ends",    value = "6"}, 
        { macro = 'GTK_MOVEMENT_PARAGRAPHS'       , name = "paragraphs",        nick = "paragraphs",        value = "5"}, 
        { macro = 'GTK_MOVEMENT_VISUAL_POSITIONS' , name = "visual_positions",  nick = "visual-positions",  value = "1"}, 
        { macro = 'GTK_MOVEMENT_WORDS'            , name = "words",             nick = "words",             value = "2"}, 
    },
    GtkNotebookTab = {
        { macro = 'GTK_NOTEBOOK_TAB_FIRST', name = "first", nick = "first", value = "0"}, 
        { macro = 'GTK_NOTEBOOK_TAB_LAST' , name = "last",  nick = "last",  value = "1"}, 
    },
    GtkNumberUpLayout = {
        { macro = 'GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT', name = "btlr", nick = "btlr", value = "6"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT', name = "btrl", nick = "btrl", value = "7"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP', name = "lrbt", nick = "lrbt", value = "1"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM', name = "lrtb", nick = "lrtb", value = "0"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP', name = "rlbt", nick = "rlbt", value = "3"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM', name = "rltb", nick = "rltb", value = "2"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT', name = "tblr", nick = "tblr", value = "4"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT', name = "tbrl", nick = "tbrl", value = "5"}, 
    },
    GtkOrientation = {
        { macro = 'GTK_ORIENTATION_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "0"}, 
        { macro = 'GTK_ORIENTATION_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "1"}, 
    },
    GtkPackDirection = {
        { macro = 'GTK_PACK_DIRECTION_BTT', name = "btt", nick = "btt", value = "3"}, 
        { macro = 'GTK_PACK_DIRECTION_LTR', name = "ltr", nick = "ltr", value = "0"}, 
        { macro = 'GTK_PACK_DIRECTION_RTL', name = "rtl", nick = "rtl", value = "1"}, 
        { macro = 'GTK_PACK_DIRECTION_TTB', name = "ttb", nick = "ttb", value = "2"}, 
    },
    GtkPackType = {
        { macro = 'GTK_PACK_END'  , name = "end",   nick = "end",   value = "1"}, 
        { macro = 'GTK_PACK_START', name = "start", nick = "start", value = "0"}, 
    },
    GtkPageOrientation = {
        { macro = 'GTK_PAGE_ORIENTATION_LANDSCAPE'        , name = "landscape",         nick = "landscape",         value = "1"}, 
        { macro = 'GTK_PAGE_ORIENTATION_PORTRAIT'         , name = "portrait",          nick = "portrait",          value = "0"}, 
        { macro = 'GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE', name = "reverse_landscape", nick = "reverse-landscape", value = "3"}, 
        { macro = 'GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT' , name = "reverse_portrait",  nick = "reverse-portrait",  value = "2"}, 
    },
    GtkPageSet = {
        { macro = 'GTK_PAGE_SET_ALL' , name = "all",  nick = "all",  value = "0"}, 
        { macro = 'GTK_PAGE_SET_EVEN', name = "even", nick = "even", value = "1"}, 
        { macro = 'GTK_PAGE_SET_ODD' , name = "odd",  nick = "odd",  value = "2"}, 
    },
    GtkPathPriorityType = {
        { macro = 'GTK_PATH_PRIO_APPLICATION', name = "application", nick = "application", value = "8"}, 
        { macro = 'GTK_PATH_PRIO_GTK'        , name = "gtk",         nick = "gtk",         value = "4"}, 
        { macro = 'GTK_PATH_PRIO_HIGHEST'    , name = "highest",     nick = "highest",     value = "15"}, 
        { macro = 'GTK_PATH_PRIO_LOWEST'     , name = "lowest",      nick = "lowest",      value = "0"}, 
        { macro = 'GTK_PATH_PRIO_RC'         , name = "rc",          nick = "rc",          value = "12"}, 
        { macro = 'GTK_PATH_PRIO_THEME'      , name = "theme",       nick = "theme",       value = "10"}, 
    },
    GtkPathType = {
        { macro = 'GTK_PATH_CLASS'       , name = "class",        nick = "class",        value = "2"}, 
        { macro = 'GTK_PATH_WIDGET'      , name = "widget",       nick = "widget",       value = "0"}, 
        { macro = 'GTK_PATH_WIDGET_CLASS', name = "widget_class", nick = "widget-class", value = "1"}, 
    },
    GtkPolicyType = {
        { macro = 'GTK_POLICY_ALWAYS'   , name = "always",    nick = "always",    value = "0"}, 
        { macro = 'GTK_POLICY_AUTOMATIC', name = "automatic", nick = "automatic", value = "1"}, 
        { macro = 'GTK_POLICY_NEVER'    , name = "never",     nick = "never",     value = "2"}, 
    },
    GtkPositionType = {
        { macro = 'GTK_POS_BOTTOM', name = "bottom", nick = "bottom", value = "3"}, 
        { macro = 'GTK_POS_LEFT'  , name = "left",   nick = "left",   value = "0"}, 
        { macro = 'GTK_POS_RIGHT' , name = "right",  nick = "right",  value = "1"}, 
        { macro = 'GTK_POS_TOP'   , name = "top",    nick = "top",    value = "2"}, 
    },
    GtkPreviewType = {
        { macro = 'GTK_PREVIEW_COLOR'    , name = "color",     nick = "color",     value = "0"}, 
        { macro = 'GTK_PREVIEW_GRAYSCALE', name = "grayscale", nick = "grayscale", value = "1"}, 
    },
    GtkPrintDuplex = {
        { macro = 'GTK_PRINT_DUPLEX_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_PRINT_DUPLEX_SIMPLEX'   , name = "simplex",    nick = "simplex",    value = "0"}, 
        { macro = 'GTK_PRINT_DUPLEX_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkPrintError = {
        { macro = 'GTK_PRINT_ERROR_GENERAL'       , name = "general",        nick = "general",        value = "0"}, 
        { macro = 'GTK_PRINT_ERROR_INTERNAL_ERROR', name = "internal_error", nick = "internal-error", value = "1"}, 
        { macro = 'GTK_PRINT_ERROR_INVALID_FILE'  , name = "invalid_file",   nick = "invalid-file",   value = "3"}, 
        { macro = 'GTK_PRINT_ERROR_NOMEM'         , name = "nomem",          nick = "nomem",          value = "2"}, 
    },
    GtkPrintOperationAction = {
        { macro = 'GTK_PRINT_OPERATION_ACTION_EXPORT'      , name = "export",       nick = "export",       value = "3"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PREVIEW'     , name = "preview",      nick = "preview",      value = "2"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PRINT'       , name = "print",        nick = "print",        value = "1"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG', name = "print_dialog", nick = "print-dialog", value = "0"}, 
    },
    GtkPrintOperationResult = {
        { macro = 'GTK_PRINT_OPERATION_RESULT_APPLY'      , name = "apply",       nick = "apply",       value = "1"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_CANCEL'     , name = "cancel",      nick = "cancel",      value = "2"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_ERROR'      , name = "error",       nick = "error",       value = "0"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_IN_PROGRESS', name = "in_progress", nick = "in-progress", value = "3"}, 
    },
    GtkPrintPages = {
        { macro = 'GTK_PRINT_PAGES_ALL'      , name = "all",       nick = "all",       value = "0"}, 
        { macro = 'GTK_PRINT_PAGES_CURRENT'  , name = "current",   nick = "current",   value = "1"}, 
        { macro = 'GTK_PRINT_PAGES_RANGES'   , name = "ranges",    nick = "ranges",    value = "2"}, 
        { macro = 'GTK_PRINT_PAGES_SELECTION', name = "selection", nick = "selection", value = "3"}, 
    },
    GtkPrintQuality = {
        { macro = 'GTK_PRINT_QUALITY_DRAFT' , name = "draft",  nick = "draft",  value = "3"}, 
        { macro = 'GTK_PRINT_QUALITY_HIGH'  , name = "high",   nick = "high",   value = "2"}, 
        { macro = 'GTK_PRINT_QUALITY_LOW'   , name = "low",    nick = "low",    value = "0"}, 
        { macro = 'GTK_PRINT_QUALITY_NORMAL', name = "normal", nick = "normal", value = "1"}, 
    },
    GtkPrintStatus = {
        { macro = 'GTK_PRINT_STATUS_FINISHED'        , name = "finished",         nick = "finished",         value = "7"}, 
        { macro = 'GTK_PRINT_STATUS_FINISHED_ABORTED', name = "finished_aborted", nick = "finished-aborted", value = "8"}, 
        { macro = 'GTK_PRINT_STATUS_GENERATING_DATA' , name = "generating_data",  nick = "generating-data",  value = "2"}, 
        { macro = 'GTK_PRINT_STATUS_INITIAL'         , name = "initial",          nick = "initial",          value = "0"}, 
        { macro = 'GTK_PRINT_STATUS_PENDING'         , name = "pending",          nick = "pending",          value = "4"}, 
        { macro = 'GTK_PRINT_STATUS_PENDING_ISSUE'   , name = "pending_issue",    nick = "pending-issue",    value = "5"}, 
        { macro = 'GTK_PRINT_STATUS_PREPARING'       , name = "preparing",        nick = "preparing",        value = "1"}, 
        { macro = 'GTK_PRINT_STATUS_PRINTING'        , name = "printing",         nick = "printing",         value = "6"}, 
        { macro = 'GTK_PRINT_STATUS_SENDING_DATA'    , name = "sending_data",     nick = "sending-data",     value = "3"}, 
    },
    GtkProgressBarOrientation = {
        { macro = 'GTK_PROGRESS_BOTTOM_TO_TOP', name = "bottom_to_top", nick = "bottom-to-top", value = "2"}, 
        { macro = 'GTK_PROGRESS_LEFT_TO_RIGHT', name = "left_to_right", nick = "left-to-right", value = "0"}, 
        { macro = 'GTK_PROGRESS_RIGHT_TO_LEFT', name = "right_to_left", nick = "right-to-left", value = "1"}, 
        { macro = 'GTK_PROGRESS_TOP_TO_BOTTOM', name = "top_to_bottom", nick = "top-to-bottom", value = "3"}, 
    },
    GtkProgressBarStyle = {
        { macro = 'GTK_PROGRESS_CONTINUOUS', name = "continuous", nick = "continuous", value = "0"}, 
        { macro = 'GTK_PROGRESS_DISCRETE'  , name = "discrete",   nick = "discrete",   value = "1"}, 
    },
    GtkRcTokenType = {
        { macro = 'GTK_RC_TOKEN_ACTIVE'        , name = "active",         nick = "active",         value = "273"}, 
        { macro = 'GTK_RC_TOKEN_APPLICATION'   , name = "application",    nick = "application",    value = "296"}, 
        { macro = 'GTK_RC_TOKEN_BASE'          , name = "base",           nick = "base",           value = "280"}, 
        { macro = 'GTK_RC_TOKEN_BG'            , name = "bg",             nick = "bg",             value = "278"}, 
        { macro = 'GTK_RC_TOKEN_BG_PIXMAP'     , name = "bg_pixmap",      nick = "bg-pixmap",      value = "286"}, 
        { macro = 'GTK_RC_TOKEN_BIND'          , name = "bind",           nick = "bind",           value = "290"}, 
        { macro = 'GTK_RC_TOKEN_BINDING'       , name = "binding",        nick = "binding",        value = "289"}, 
        { macro = 'GTK_RC_TOKEN_CLASS'         , name = "class",          nick = "class",          value = "293"}, 
        { macro = 'GTK_RC_TOKEN_COLOR'         , name = "color",          nick = "color",          value = "307"}, 
        { macro = 'GTK_RC_TOKEN_ENGINE'        , name = "engine",         nick = "engine",         value = "300"}, 
        { macro = 'GTK_RC_TOKEN_FG'            , name = "fg",             nick = "fg",             value = "277"}, 
        { macro = 'GTK_RC_TOKEN_FONT'          , name = "font",           nick = "font",           value = "283"}, 
        { macro = 'GTK_RC_TOKEN_FONT_NAME'     , name = "font_name",      nick = "font-name",      value = "285"}, 
        { macro = 'GTK_RC_TOKEN_FONTSET'       , name = "fontset",        nick = "fontset",        value = "284"}, 
        { macro = 'GTK_RC_TOKEN_GTK'           , name = "gtk",            nick = "gtk",            value = "295"}, 
        { macro = 'GTK_RC_TOKEN_HIGHEST'       , name = "highest",        nick = "highest",        value = "299"}, 
        { macro = 'GTK_RC_TOKEN_IM_MODULE_FILE', name = "im_module_file", nick = "im-module-file", value = "303"}, 
        { macro = 'GTK_RC_TOKEN_IM_MODULE_PATH', name = "im_module_path", nick = "im-module-path", value = "302"}, 
        { macro = 'GTK_RC_TOKEN_INCLUDE'       , name = "include",        nick = "include",        value = "271"}, 
        { macro = 'GTK_RC_TOKEN_INSENSITIVE'   , name = "insensitive",    nick = "insensitive",    value = "276"}, 
        { macro = 'GTK_RC_TOKEN_INVALID'       , name = "invalid",        nick = "invalid",        value = "270"}, 
        { macro = 'GTK_RC_TOKEN_LAST'          , name = "last",           nick = "last",           value = "309"}, 
        { macro = 'GTK_RC_TOKEN_LOWEST'        , name = "lowest",         nick = "lowest",         value = "294"}, 
        { macro = 'GTK_RC_TOKEN_LTR'           , name = "ltr",            nick = "ltr",            value = "305"}, 
        { macro = 'GTK_RC_TOKEN_MODULE_PATH'   , name = "module_path",    nick = "module-path",    value = "301"}, 
        { macro = 'GTK_RC_TOKEN_NORMAL'        , name = "normal",         nick = "normal",         value = "272"}, 
        { macro = 'GTK_RC_TOKEN_PIXMAP_PATH'   , name = "pixmap_path",    nick = "pixmap-path",    value = "287"}, 
        { macro = 'GTK_RC_TOKEN_PRELIGHT'      , name = "prelight",       nick = "prelight",       value = "274"}, 
        { macro = 'GTK_RC_TOKEN_RC'            , name = "rc",             nick = "rc",             value = "298"}, 
        { macro = 'GTK_RC_TOKEN_RTL'           , name = "rtl",            nick = "rtl",            value = "306"}, 
        { macro = 'GTK_RC_TOKEN_SELECTED'      , name = "selected",       nick = "selected",       value = "275"}, 
        { macro = 'GTK_RC_TOKEN_STOCK'         , name = "stock",          nick = "stock",          value = "304"}, 
        { macro = 'GTK_RC_TOKEN_STYLE'         , name = "style",          nick = "style",          value = "288"}, 
        { macro = 'GTK_RC_TOKEN_TEXT'          , name = "text",           nick = "text",           value = "279"}, 
        { macro = 'GTK_RC_TOKEN_THEME'         , name = "theme",          nick = "theme",          value = "297"}, 
        { macro = 'GTK_RC_TOKEN_UNBIND'        , name = "unbind",         nick = "unbind",         value = "308"}, 
        { macro = 'GTK_RC_TOKEN_WIDGET'        , name = "widget",         nick = "widget",         value = "291"}, 
        { macro = 'GTK_RC_TOKEN_WIDGET_CLASS'  , name = "widget_class",   nick = "widget-class",   value = "292"}, 
        { macro = 'GTK_RC_TOKEN_XTHICKNESS'    , name = "xthickness",     nick = "xthickness",     value = "281"}, 
        { macro = 'GTK_RC_TOKEN_YTHICKNESS'    , name = "ythickness",     nick = "ythickness",     value = "282"}, 
    },
    GtkRecentChooserError = {
        { macro = 'GTK_RECENT_CHOOSER_ERROR_INVALID_URI', name = "invalid_uri", nick = "invalid-uri", value = "1"}, 
        { macro = 'GTK_RECENT_CHOOSER_ERROR_NOT_FOUND'  , name = "not_found",   nick = "not-found",   value = "0"}, 
    },
    GtkRecentManagerError = {
        { macro = 'GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING', name = "invalid_encoding", nick = "invalid-encoding", value = "2"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_INVALID_URI'     , name = "invalid_uri",      nick = "invalid-uri",      value = "1"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_NOT_FOUND'       , name = "not_found",        nick = "not-found",        value = "0"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED'  , name = "not_registered",   nick = "not-registered",   value = "3"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_READ'            , name = "read",             nick = "read",             value = "4"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_UNKNOWN'         , name = "unknown",          nick = "unknown",          value = "6"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_WRITE'           , name = "write",            nick = "write",            value = "5"}, 
    },
    GtkRecentSortType = {
        { macro = 'GTK_RECENT_SORT_CUSTOM', name = "custom", nick = "custom", value = "3"}, 
        { macro = 'GTK_RECENT_SORT_LRU'   , name = "lru",    nick = "lru",    value = "2"}, 
        { macro = 'GTK_RECENT_SORT_MRU'   , name = "mru",    nick = "mru",    value = "1"}, 
        { macro = 'GTK_RECENT_SORT_NONE'  , name = "none",   nick = "none",   value = "0"}, 
    },
    GtkReliefStyle = {
        { macro = 'GTK_RELIEF_HALF'  , name = "half",   nick = "half",   value = "1"}, 
        { macro = 'GTK_RELIEF_NONE'  , name = "none",   nick = "none",   value = "2"}, 
        { macro = 'GTK_RELIEF_NORMAL', name = "normal", nick = "normal", value = "0"}, 
    },
    GtkResizeMode = {
        { macro = 'GTK_RESIZE_IMMEDIATE', name = "immediate", nick = "immediate", value = "2"}, 
        { macro = 'GTK_RESIZE_PARENT'   , name = "parent",    nick = "parent",    value = "0"}, 
        { macro = 'GTK_RESIZE_QUEUE'    , name = "queue",     nick = "queue",     value = "1"}, 
    },
    GtkResponseType = {
        { macro = 'GTK_RESPONSE_ACCEPT'      , name = "accept",       nick = "accept",       value = "-3"}, 
        { macro = 'GTK_RESPONSE_APPLY'       , name = "apply",        nick = "apply",        value = "-10"}, 
        { macro = 'GTK_RESPONSE_CANCEL'      , name = "cancel",       nick = "cancel",       value = "-6"}, 
        { macro = 'GTK_RESPONSE_CLOSE'       , name = "close",        nick = "close",        value = "-7"}, 
        { macro = 'GTK_RESPONSE_DELETE_EVENT', name = "delete_event", nick = "delete-event", value = "-4"}, 
        { macro = 'GTK_RESPONSE_HELP'        , name = "help",         nick = "help",         value = "-11"}, 
        { macro = 'GTK_RESPONSE_NO'          , name = "no",           nick = "no",           value = "-9"}, 
        { macro = 'GTK_RESPONSE_NONE'        , name = "none",         nick = "none",         value = "-1"}, 
        { macro = 'GTK_RESPONSE_OK'          , name = "ok",           nick = "ok",           value = "-5"}, 
        { macro = 'GTK_RESPONSE_REJECT'      , name = "reject",       nick = "reject",       value = "-2"}, 
        { macro = 'GTK_RESPONSE_YES'         , name = "yes",          nick = "yes",          value = "-8"}, 
    },
    GtkScrollStep = {
        { macro = 'GTK_SCROLL_ENDS'            , name = "ends",             nick = "ends",             value = "2"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_ENDS' , name = "horizontal_ends",  nick = "horizontal-ends",  value = "5"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_PAGES', name = "horizontal_pages", nick = "horizontal-pages", value = "4"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_STEPS', name = "horizontal_steps", nick = "horizontal-steps", value = "3"}, 
        { macro = 'GTK_SCROLL_PAGES'           , name = "pages",            nick = "pages",            value = "1"}, 
        { macro = 'GTK_SCROLL_STEPS'           , name = "steps",            nick = "steps",            value = "0"}, 
    },
    GtkScrollType = {
        { macro = 'GTK_SCROLL_END'          , name = "end",           nick = "end",           value = "15"}, 
        { macro = 'GTK_SCROLL_JUMP'         , name = "jump",          nick = "jump",          value = "1"}, 
        { macro = 'GTK_SCROLL_NONE'         , name = "none",          nick = "none",          value = "0"}, 
        { macro = 'GTK_SCROLL_PAGE_BACKWARD', name = "page_backward", nick = "page-backward", value = "4"}, 
        { macro = 'GTK_SCROLL_PAGE_DOWN'    , name = "page_down",     nick = "page-down",     value = "9"}, 
        { macro = 'GTK_SCROLL_PAGE_FORWARD' , name = "page_forward",  nick = "page-forward",  value = "5"}, 
        { macro = 'GTK_SCROLL_PAGE_LEFT'    , name = "page_left",     nick = "page-left",     value = "12"}, 
        { macro = 'GTK_SCROLL_PAGE_RIGHT'   , name = "page_right",    nick = "page-right",    value = "13"}, 
        { macro = 'GTK_SCROLL_PAGE_UP'      , name = "page_up",       nick = "page-up",       value = "8"}, 
        { macro = 'GTK_SCROLL_START'        , name = "start",         nick = "start",         value = "14"}, 
        { macro = 'GTK_SCROLL_STEP_BACKWARD', name = "step_backward", nick = "step-backward", value = "2"}, 
        { macro = 'GTK_SCROLL_STEP_DOWN'    , name = "step_down",     nick = "step-down",     value = "7"}, 
        { macro = 'GTK_SCROLL_STEP_FORWARD' , name = "step_forward",  nick = "step-forward",  value = "3"}, 
        { macro = 'GTK_SCROLL_STEP_LEFT'    , name = "step_left",     nick = "step-left",     value = "10"}, 
        { macro = 'GTK_SCROLL_STEP_RIGHT'   , name = "step_right",    nick = "step-right",    value = "11"}, 
        { macro = 'GTK_SCROLL_STEP_UP'      , name = "step_up",       nick = "step-up",       value = "6"}, 
    },
    GtkSelectionMode = {
        { macro = 'GTK_SELECTION_BROWSE'  , name = "browse",   nick = "browse",   value = "2"}, 
        { macro = 'GTK_SELECTION_EXTENDED', name = "extended", nick = "extended", value = "3"}, 
        { macro = 'GTK_SELECTION_MULTIPLE', name = "multiple", nick = "multiple", value = "3"}, 
        { macro = 'GTK_SELECTION_NONE'    , name = "none",     nick = "none",     value = "0"}, 
        { macro = 'GTK_SELECTION_SINGLE'  , name = "single",   nick = "single",   value = "1"}, 
    },
    GtkSensitivityType = {
        { macro = 'GTK_SENSITIVITY_AUTO', name = "auto", nick = "auto", value = "0"}, 
        { macro = 'GTK_SENSITIVITY_OFF' , name = "off",  nick = "off",  value = "2"}, 
        { macro = 'GTK_SENSITIVITY_ON'  , name = "on",   nick = "on",   value = "1"}, 
    },
    GtkShadowType = {
        { macro = 'GTK_SHADOW_ETCHED_IN' , name = "etched_in",  nick = "etched-in",  value = "3"}, 
        { macro = 'GTK_SHADOW_ETCHED_OUT', name = "etched_out", nick = "etched-out", value = "4"}, 
        { macro = 'GTK_SHADOW_IN'        , name = "in",         nick = "in",         value = "1"}, 
        { macro = 'GTK_SHADOW_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_SHADOW_OUT'       , name = "out",        nick = "out",        value = "2"}, 
    },
    GtkSideType = {
        { macro = 'GTK_SIDE_BOTTOM', name = "bottom", nick = "bottom", value = "1"}, 
        { macro = 'GTK_SIDE_LEFT'  , name = "left",   nick = "left",   value = "2"}, 
        { macro = 'GTK_SIDE_RIGHT' , name = "right",  nick = "right",  value = "3"}, 
        { macro = 'GTK_SIDE_TOP'   , name = "top",    nick = "top",    value = "0"}, 
    },
    GtkSizeGroupMode = {
        { macro = 'GTK_SIZE_GROUP_BOTH'      , name = "both",       nick = "both",       value = "3"}, 
        { macro = 'GTK_SIZE_GROUP_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_SIZE_GROUP_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_SIZE_GROUP_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkSortType = {
        { macro = 'GTK_SORT_ASCENDING' , name = "ascending",  nick = "ascending",  value = "0"}, 
        { macro = 'GTK_SORT_DESCENDING', name = "descending", nick = "descending", value = "1"}, 
    },
    GtkSpinButtonUpdatePolicy = {
        { macro = 'GTK_UPDATE_ALWAYS'  , name = "always",   nick = "always",   value = "0"}, 
        { macro = 'GTK_UPDATE_IF_VALID', name = "if_valid", nick = "if-valid", value = "1"}, 
    },
    GtkSpinType = {
        { macro = 'GTK_SPIN_END'          , name = "end",           nick = "end",           value = "5"}, 
        { macro = 'GTK_SPIN_HOME'         , name = "home",          nick = "home",          value = "4"}, 
        { macro = 'GTK_SPIN_PAGE_BACKWARD', name = "page_backward", nick = "page-backward", value = "3"}, 
        { macro = 'GTK_SPIN_PAGE_FORWARD' , name = "page_forward",  nick = "page-forward",  value = "2"}, 
        { macro = 'GTK_SPIN_STEP_BACKWARD', name = "step_backward", nick = "step-backward", value = "1"}, 
        { macro = 'GTK_SPIN_STEP_FORWARD' , name = "step_forward",  nick = "step-forward",  value = "0"}, 
        { macro = 'GTK_SPIN_USER_DEFINED' , name = "user_defined",  nick = "user-defined",  value = "6"}, 
    },
    GtkStateType = {
        { macro = 'GTK_STATE_ACTIVE'     , name = "active",      nick = "active",      value = "1"}, 
        { macro = 'GTK_STATE_INSENSITIVE', name = "insensitive", nick = "insensitive", value = "4"}, 
        { macro = 'GTK_STATE_NORMAL'     , name = "normal",      nick = "normal",      value = "0"}, 
        { macro = 'GTK_STATE_PRELIGHT'   , name = "prelight",    nick = "prelight",    value = "2"}, 
        { macro = 'GTK_STATE_SELECTED'   , name = "selected",    nick = "selected",    value = "3"}, 
    },
    GtkSubmenuDirection = {
        { macro = 'GTK_DIRECTION_LEFT' , name = "left",  nick = "left",  value = "0"}, 
        { macro = 'GTK_DIRECTION_RIGHT', name = "right", nick = "right", value = "1"}, 
    },
    GtkSubmenuPlacement = {
        { macro = 'GTK_LEFT_RIGHT', name = "left_right", nick = "left-right", value = "1"}, 
        { macro = 'GTK_TOP_BOTTOM', name = "top_bottom", nick = "top-bottom", value = "0"}, 
    },
    GtkTextBufferTargetInfo = {
        { macro = 'GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS', name = "buffer_contents", nick = "buffer-contents", value = "-1"}, 
        { macro = 'GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT'      , name = "rich_text",       nick = "rich-text",       value = "-2"}, 
        { macro = 'GTK_TEXT_BUFFER_TARGET_INFO_TEXT'           , name = "text",            nick = "text",            value = "-3"}, 
    },
    GtkTextDirection = {
        { macro = 'GTK_TEXT_DIR_LTR' , name = "ltr",  nick = "ltr",  value = "1"}, 
        { macro = 'GTK_TEXT_DIR_NONE', name = "none", nick = "none", value = "0"}, 
        { macro = 'GTK_TEXT_DIR_RTL' , name = "rtl",  nick = "rtl",  value = "2"}, 
    },
    GtkTextWindowType = {
        { macro = 'GTK_TEXT_WINDOW_BOTTOM' , name = "bottom",  nick = "bottom",  value = "6"}, 
        { macro = 'GTK_TEXT_WINDOW_LEFT'   , name = "left",    nick = "left",    value = "3"}, 
        { macro = 'GTK_TEXT_WINDOW_PRIVATE', name = "private", nick = "private", value = "0"}, 
        { macro = 'GTK_TEXT_WINDOW_RIGHT'  , name = "right",   nick = "right",   value = "4"}, 
        { macro = 'GTK_TEXT_WINDOW_TEXT'   , name = "text",    nick = "text",    value = "2"}, 
        { macro = 'GTK_TEXT_WINDOW_TOP'    , name = "top",     nick = "top",     value = "5"}, 
        { macro = 'GTK_TEXT_WINDOW_WIDGET' , name = "widget",  nick = "widget",  value = "1"}, 
    },
    GtkToolbarChildType = {
        { macro = 'GTK_TOOLBAR_CHILD_BUTTON'      , name = "button",       nick = "button",       value = "1"}, 
        { macro = 'GTK_TOOLBAR_CHILD_RADIOBUTTON' , name = "radiobutton",  nick = "radiobutton",  value = "3"}, 
        { macro = 'GTK_TOOLBAR_CHILD_SPACE'       , name = "space",        nick = "space",        value = "0"}, 
        { macro = 'GTK_TOOLBAR_CHILD_TOGGLEBUTTON', name = "togglebutton", nick = "togglebutton", value = "2"}, 
        { macro = 'GTK_TOOLBAR_CHILD_WIDGET'      , name = "widget",       nick = "widget",       value = "4"}, 
    },
    GtkToolbarSpaceStyle = {
        { macro = 'GTK_TOOLBAR_SPACE_EMPTY', name = "empty", nick = "empty", value = "0"}, 
        { macro = 'GTK_TOOLBAR_SPACE_LINE' , name = "line",  nick = "line",  value = "1"}, 
    },
    GtkToolbarStyle = {
        { macro = 'GTK_TOOLBAR_BOTH'      , name = "both",       nick = "both",       value = "2"}, 
        { macro = 'GTK_TOOLBAR_BOTH_HORIZ', name = "both_horiz", nick = "both-horiz", value = "3"}, 
        { macro = 'GTK_TOOLBAR_ICONS'     , name = "icons",      nick = "icons",      value = "0"}, 
        { macro = 'GTK_TOOLBAR_TEXT'      , name = "text",       nick = "text",       value = "1"}, 
    },
    GtkTreeViewColumnSizing = {
        { macro = 'GTK_TREE_VIEW_COLUMN_AUTOSIZE' , name = "autosize",  nick = "autosize",  value = "1"}, 
        { macro = 'GTK_TREE_VIEW_COLUMN_FIXED'    , name = "fixed",     nick = "fixed",     value = "2"}, 
        { macro = 'GTK_TREE_VIEW_COLUMN_GROW_ONLY', name = "grow_only", nick = "grow-only", value = "0"}, 
    },
    GtkTreeViewDropPosition = {
        { macro = 'GTK_TREE_VIEW_DROP_AFTER'         , name = "after",          nick = "after",          value = "1"}, 
        { macro = 'GTK_TREE_VIEW_DROP_BEFORE'        , name = "before",         nick = "before",         value = "0"}, 
        { macro = 'GTK_TREE_VIEW_DROP_INTO_OR_AFTER' , name = "into_or_after",  nick = "into-or-after",  value = "3"}, 
        { macro = 'GTK_TREE_VIEW_DROP_INTO_OR_BEFORE', name = "into_or_before", nick = "into-or-before", value = "2"}, 
    },
    GtkTreeViewGridLines = {
        { macro = 'GTK_TREE_VIEW_GRID_LINES_BOTH'      , name = "both",       nick = "both",       value = "3"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkTreeViewMode = {
        { macro = 'GTK_TREE_VIEW_ITEM', name = "item", nick = "item", value = "1"}, 
        { macro = 'GTK_TREE_VIEW_LINE', name = "line", nick = "line", value = "0"}, 
    },
    GtkUnit = {
        { macro = 'GTK_UNIT_INCH'  , name = "inch",   nick = "inch",   value = "2"}, 
        { macro = 'GTK_UNIT_MM'    , name = "mm",     nick = "mm",     value = "3"}, 
        { macro = 'GTK_UNIT_PIXEL' , name = "pixel",  nick = "pixel",  value = "0"}, 
        { macro = 'GTK_UNIT_POINTS', name = "points", nick = "points", value = "1"}, 
    },
    GtkUpdateType = {
        { macro = 'GTK_UPDATE_CONTINUOUS'   , name = "continuous",    nick = "continuous",    value = "0"}, 
        { macro = 'GTK_UPDATE_DELAYED'      , name = "delayed",       nick = "delayed",       value = "2"}, 
        { macro = 'GTK_UPDATE_DISCONTINUOUS', name = "discontinuous", nick = "discontinuous", value = "1"}, 
    },
    GtkVisibility = {
        { macro = 'GTK_VISIBILITY_FULL'   , name = "full",    nick = "full",    value = "2"}, 
        { macro = 'GTK_VISIBILITY_NONE'   , name = "none",    nick = "none",    value = "0"}, 
        { macro = 'GTK_VISIBILITY_PARTIAL', name = "partial", nick = "partial", value = "1"}, 
    },
    GtkWidgetHelpType = {
        { macro = 'GTK_WIDGET_HELP_TOOLTIP'   , name = "tooltip",    nick = "tooltip",    value = "0"}, 
        { macro = 'GTK_WIDGET_HELP_WHATS_THIS', name = "whats_this", nick = "whats-this", value = "1"}, 
    },
    GtkWindowPosition = {
        { macro = 'GTK_WIN_POS_CENTER'          , name = "center",           nick = "center",           value = "1"}, 
        { macro = 'GTK_WIN_POS_CENTER_ALWAYS'   , name = "center_always",    nick = "center-always",    value = "3"}, 
        { macro = 'GTK_WIN_POS_CENTER_ON_PARENT', name = "center_on_parent", nick = "center-on-parent", value = "4"}, 
        { macro = 'GTK_WIN_POS_MOUSE'           , name = "mouse",            nick = "mouse",            value = "2"}, 
        { macro = 'GTK_WIN_POS_NONE'            , name = "none",             nick = "none",             value = "0"}, 
    },
    GtkWindowType = {
        { macro = 'GTK_WINDOW_POPUP'   , name = "popup",    nick = "popup",    value = "1"}, 
        { macro = 'GTK_WINDOW_TOPLEVEL', name = "toplevel", nick = "toplevel", value = "0"}, 
    },
    GtkWrapMode = {
        { macro = 'GTK_WRAP_CHAR'     , name = "char",      nick = "char",      value = "1"}, 
        { macro = 'GTK_WRAP_NONE'     , name = "none",      nick = "none",      value = "0"}, 
        { macro = 'GTK_WRAP_WORD'     , name = "word",      nick = "word",      value = "2"}, 
        { macro = 'GTK_WRAP_WORD_CHAR', name = "word_char", nick = "word-char", value = "3"}, 
    },
}); end;
----  [Gtk Enumerates] End ... 

---------------- gtk20.patch.lua，控件大致按照字母顺序（除个别存在前置依赖关系）

---------------------  GtkPageSetupUnixDialog
Gtk224.GtkPageSetupUnixDialog = {
  class = "GtkPageSetupUnixDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_page_setup_unix_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
  -- 还需要依赖其他的特殊模块
  ext_modules = {"gtk+-unix-print-2.0"},
  -- 此模块依赖的外部头文件
  ext_inc_files = {"gtk/gtkunixprint.h"},
};

---------------------  GtkPrintUnixDialog
Gtk224.GtkPrintUnixDialog = {
  class = "GtkPrintUnixDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_unix_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk224.GtkDialog,
  implement = {Gtk224.GtkBuildable}, 
  -- 还需要依赖其他的特殊模块
  ext_modules = {"gtk+-unix-print-2.0"},
  -- 此模块依赖的外部头文件
  ext_inc_files = {"gtk/gtkunixprint.h"},
};

function Gtk224.table_copy_table_in_patch(ori_tab)
  if (type(ori_tab) ~= "table") then
      return nil, 0
  end
  local new_tab = {}
  local max_index = 1
  for i,v in pairs(ori_tab) do
      local vtyp = type(v)
      if (vtyp == "table") then
          new_tab[i] = Gtk224.table_copy_table_in_patch(v)
      elseif (vtyp == "thread") then
          new_tab[i] = v
      elseif (vtyp == "userdata") then
          new_tab[i] = v
      else
          new_tab[i] = v
      end
  max_index = max_index + 1
  end
  return new_tab, max_index
end

-- 往表中插入多条记录
function Gtk224.insert_more(tbl, ...)
    local args = { ... }
    for _, item in ipairs(args) do
        table.insert(tbl, item);
    end
end;

-- 往表中插入多条记录
function Gtk224.copy_and_insert_more(tbl, ...)
  local args = { ... }
  local new_tbl = table.pack(table.unpack(tbl))
  -- 删除新表中的n字段
  new_tbl.n = nil;
  for _, item in ipairs(args) do
    table.insert(new_tbl, item);
  end
  return new_tbl;
end;

-- 对于某些特定的类，需要一个统一补丁函数，生成g_object_set的生成代码
function Gtk224.PatchGlibProperty(class, property_list)
  local function string_starts(String,Start)
      return string.sub(String,1,string.len(Start))==Start
  end
  local function string_ends(String,End)
      return End=='' or string.sub(String,-string.len(End))==End
  end
  local function item_is_in_table(name, tbl)
    for _, item in ipairs(tbl) do
        if name == item then
            return true
        end
    end
    return false
  end
  -- 传入类实例，直接进行Patch操作
  if class.property ~= nil then
      -- 优化一下传入property_list时的处理方式
      local check_property_list = class.property;
      -- 如果不为空，则可以做一个临时的小对象
      if property_list ~= nil and type(property_list) == "table" then
          check_property_list = {}
          for _, prop_name in ipairs(property_list) do
              if class.property[prop_name] == nil then
                  print("[ERROR] PatchGlibProperty fail, missing " .. prop_name " in " .. class.class)
              else
                check_property_list[prop_name] = class.property[prop_name]
              end
          end
      end
      for prop_name, property in pairs(check_property_list) do
          -- 跳过特殊字段
          if (not string_starts(prop_name, "__")) or (not string_ends(prop_name, "__")) then
              local real_prop_name = string.gsub(prop_name, "_", "-")
              -- 如果是处理全部属性，或者 指定了需要处理的属性
              if property_list == nil or item_is_in_table(prop_name, property_list) or item_is_in_table(real_prop_name, property_list) then
                    -- 如果生成代码为空，且rwflags为空或者为可读写rw
                    if property.__gencode__ == nil and (property.rwflags == nil or property.rwflags == "rw" or property.rwflags == "w") then
                        property.__gencode__ = {"g_object_set(G_OBJECT ({* id *}), \"" ..  real_prop_name .. "\", (".. property.__type__ .. ")({* property.value *}), NULL)"}
                    end
            end
          end
      end
  end
end

----------------==  GtkActivatable
----------------==  GtkBuildable
----------------==  GtkCellEditable
----------------==  GtkCellLayout
----------------==  GtkEditable
----------------==  GtkFileChooser
Gtk224.PatchGlibProperty(Gtk224.GtkFileChooser, {"file_system_backend"});

----------------==  GtkOrientable
----------------==  GtkPrintOperationPreview
----------------==  GtkRecentChooser
Gtk224.PatchGlibProperty(Gtk224.GtkRecentChooser, {"recent_manager"});

----------------==  GtkToolShell
----------------==  GtkTreeDragDest
----------------==  GtkTreeDragSource
----------------==  GtkTreeModel
----------------==  GtkTreeSortable

----------------==  GtkAccelGroup
----------------==  GtkAccelMap
----------------==  GtkAccessible
----------------==  GtkAction
-- GtkAction的构建以name为关键字，其label、tooltip、stock_id三个属性属于可选
Gtk224.GtkAction.property["name"]["__construct__"] = 1
Gtk224.GtkAction.property["label"]["__construct__"] = 1
Gtk224.GtkAction.property["tooltip"]["__construct__"] = 1
Gtk224.GtkAction.property["stock_id"]["__construct__"] = 1
Gtk224.PatchGlibProperty(Gtk224.GtkAction, {"hide_if_empty", "visible_overflown"});

----------------==  GtkActionGroup
Gtk224.GtkActionGroup.child_property = { 
    -- 属性名称  属性类型 缺省值
    key       = {__type__="gchar*"          ,__default__ = "F1"               , macro_code = {uisources = "ADD_ACCEL_TO_ACTION_GROUP"}},
    modifiers = {__type__="GdkModifierType" ,__default__ = "GDK_CONTROL_MASK" },
    label     = {__type__="gchar*"},
};


--[[
  类中的packing数据规则说明：
    1、packing表（数组格式）的每个子项都是一个表，顺序存放，判断需要哪些packing_build时，会先取得当前实例数据中所有的packing属性数据字段名称（name列表）
    2、packing子项(字典格式)中，group字段是一个数组，其中存放属性名，仅当当前实例packing属性数据中全部包含相应的属性名，才命中此子项条目
    3、命中条目后，会将子项的group_code（数组格式）依次拷贝packing_build用于输出代码，同时删除group_code中每个子项的name列表、filter_out列表
    4、删除后的name列表如果不为空，会继续下一packing子项的匹配，如果子项结束，但当前类存在父类，则递归继续匹配，直到全部匹配结束、或者父类为空
    5、生成代码时，packing_build列表内容是group_code子项的合并项，列表中每个子项都会进行处理并生成代码，每个packing_build子项结构与group_code子项结构完全一致
    6、packing_build子项在生成代码时会判断name字段中对应packing属性是否存在，如果不存在，则需要取得默认值，以供gen_code使用。
    7、如果name中的字段，有一项在packing属性中不存在，同时当前子项存在can_skip字段，则会跳过此条目的代码生成
]]--
Gtk224.GtkActionGroup["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {"key", "modifiers"}, group_code = { { name = {"key", "modifiers"},  
          gen_code = "ADD_ACCEL_TO_ACTION_GROUP((GtkActionGroup*){* id *}, (GtkAction*){* child.id.value *}, {* packing.key.value *}, (GdkModifierType)({* packing.modifiers.value *}))"},
        },
    },
    {
        -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {},  
            gen_code = "gtk_action_group_add_action((GtkActionGroup*){* id *}, (GtkAction*){* child.id.value *})"},
        },
    },
};

----------------==  GtkBuilder
----------------==  GtkClipboard
----------------==  GtkEntryBuffer
Gtk224.GtkEntryBuffer.constructor.new.gencode = "gtk_entry_buffer_new((const gchar*)(NULL), (gint)(0))";
Gtk224.GtkEntryBuffer.property.text.__gencode__ = {"gtk_entry_buffer_set_text((GtkEntryBuffer*)({* id *}), (const gchar*)({* property.value *}), -1)"}

----------------==  GtkEntryCompletion
----------------==  GtkIMContext
----------------==  GtkIconFactory
Gtk224.GtkIconFactory.child_property = { 
    -- 属性名称  属性类型 缺省值
    stock_id    = {__type__="gchar*"},
};
Gtk224.GtkIconFactory.packing = {
    {
        -- 用于判断是否属于当前组
        group = {"stock_id"}, group_code = {
            { name = {"stock_id"},  gen_code = "gtk_icon_factory_add((GtkIconFactory*){* id *}, (const gchar*){* packing.stock_id.value *}, (GtkIconSet*){* child.id.value *})"},
            { name = {"stock_id"},  gen_code = "gtk_icon_set_unref((GtkIconSet*){* child.id.value *})"},
        },
    },
};
Gtk224.GtkIconSet = {
  class = "GtkIconSet", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_icon_set_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  packing = {
      {
          -- 用于判断是否属于当前组
          group = {}, group_code = {
              { name = {},  gen_code = "gtk_icon_set_add_source((GtkIconSet*){* id *}, (GtkIconSource*){* child.id.value *})"},
              { name = {},  gen_code = "gtk_icon_source_free((GtkIconSource*){* child.id.value *})"},
          },
      },
  },
  parent = nil, 
};
Gtk224.GtkIconSource = {
  class = "GtkIconSource", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_icon_source_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filename   = {__type__="gchar*"           ,__default__ = "NULL",  __gencode__ = {"gtk_icon_source_set_filename((GtkIconSource*)({* id *}), (const gchar*)({* property.value *}))"} },
    icon_name  = {__type__="gchar*"           ,__default__ = "NULL",  __gencode__ = {"gtk_icon_source_set_icon_name((GtkIconSource*)({* id *}), (const gchar*)({* property.value *}))"} },
    size       = {__type__="GtkIconSize"      ,__default__ = "-1" ,   __gencode__ = {"gtk_icon_source_set_size((GtkIconSource*)({* id *}), (GtkIconSize)({* property.value *}))"} },
    direction  = {__type__="GtkTextDirection" ,__default__ = "-1" ,   __gencode__ = {"gtk_icon_source_set_direction((GtkIconSource*)({* id *}), (GtkTextDirection)({* property.value *}))"} },
    state      = {__type__="GtkStateType"     ,__default__ = "-1" ,   __gencode__ = {"gtk_icon_source_set_state((GtkIconSource*)({* id *}), (GtkStateType)({* property.value *}))"} },
  },
  parent = nil, 
};

----------------==  GtkIconTheme
----------------==  GtkIdentifier
----------------==  GtkListStore

-- GtkListStore的第一个属性是column_0，然后是column_1，column_2，...，最后以column_count结尾
-- 这里利用了生成属性代码中使用Gtkui.pairs对属性进行了排序的特性
Gtk224.GtkListStore.property["column_0"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"static GType __{*id*}_gtypes__[{* property.value *} + 1] = { //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk224.GtkListStore.property["^column_%d+$"] = {__type__="GType*", regex = true,
                               __gencode__ = {"    {* Gtkui.GlibBaseTypeToGType(property.value) *}, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk224.GtkListStore.property["column_count"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"G_TYPE_INT}",
                                    "gtk_list_store_set_column_types((GtkListStore*){* id *}, (gint){* property.value *}, __{*id*}_gtypes__)"}};

--- 生成GtkListStore的data属性代码
Gtk224.GtkListStore.property["^data_%d+_######$"] = {__type__="gint", regex = true,
                      __gencode__ = {"{ //",
                                    "    GtkTreeIter iter", 
                                    "    gtk_list_store_append ((GtkListStore*){* id *}, &iter)",
                                    "    gtk_list_store_set ((GtkListStore*){* id *}, &iter, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk224.GtkListStore.property["^data_%d+_%d+$"] = {__type__="GType*", regex = true,
                      __gencode__ = {"        {* Gtkui.GlibBaseTypeToGType(property.type) *}, {* property.value *}, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk224.GtkListStore.property["^data_%d+_======$"] = {__type__="gint", regex = true,
                      __gencode__ = {"    -1)", "}"}};

-- GtkListStore的构建函数
Gtk224.GtkListStore.constructor["new"] = { gencode = "gtk_list_store_new((gint)1, G_TYPE_INT)", params = { type = {}, name = {} } };
--GtkListStore.constructor["new"] = { gencode = "gtk_list_store_new((gint)({* this.n_columns.value *}), {% for idx=1,this.n_columns.value do %}G_TYPE_INT, {% end %} G_TYPE_INT)",
--                                        params = { type = {"gint"}, name = {"n_columns"} } };
Gtk224.GtkListStore.constructor["newv"] = nil;

----------------==  GtkMountOperation
----------------==  GtkObject
----------------==  GtkPageSetup
----------------==  GtkPrintContext
----------------==  GtkPrintOperation
----------------==  GtkPrintSettings
----------------==  GtkRcStyle
----------------==  GtkRecentManager
----------------==  GtkSettings
----------------==  GtkSizeGroup
----- top_widget存储相应根控件，widget_%d存储子控件，所有子控件必须在根控件中
Gtk224.GtkSizeGroup.property["top_widget"] = {__type__="GtkWidget*", __gencode__ = {""}, macro_code = {uisources = "GTK_SIZE_GROUP_LOOKUP"}};
Gtk224.GtkSizeGroup.property["^widget_%d+$"] = {__type__="GtkWidget*", regex = true, ext_depend = true,
                __gencode__ = {"gtk_size_group_add_widget((GtkSizeGroup*){* id *}, (GtkWidget*)GTK_SIZE_GROUP_LOOKUP({* this.top_widget.value *}, {* property.value *}))"}};
Gtk224.GtkSizeGroup.property["widget_count"] = {__type__="guint", __gencode__ = {""}};

----------------==  GtkStatusIcon
Gtk224.GtkStatusIcon.constructor.new_from_file = { gencode = "gtk_status_icon_new_from_file((const gchar*)({* this.file.value *}))",
                                                  params = { type = {"gchar*"}, name = {"file"} } };
Gtk224.GtkStatusIcon.constructor.new_from_gicon = { gencode = "gtk_status_icon_new_from_gicon((GIcon*)({* this.gicon.value *}))",
                                                  params = { type = {"GIcon*"}, name = {"gicon"} } };
Gtk224.GtkStatusIcon.constructor.new_from_stock = { gencode = "gtk_status_icon_new_from_stock((const gchar*)({* this.stock.value *}))",
                                                  params = { type = {"gchar*"}, name = {"stock"} } };

----------------==  GtkStyle
----------------==  GtkTextBuffer
-- 需要patch GtkTextBuffer["constructor"]的new
Gtk224.GtkTextBuffer.constructor["new"] = { gencode = "gtk_text_buffer_new((GtkTextTagTable*)({* this.tag_table.value *}))",
                                        params = { type = {"GtkTextTagTable*"}, name = {"tag_table"} } };
-- 需要patch GtkTextBuffer_property的tag_table
Gtk224.GtkTextBuffer.property["tag_table"]["__default__"] = "NULL"
Gtk224.GtkTextBuffer.property["tag_table"]["__construct__"] = 1
-- 需要patch GtkTextBuffer_property的text
Gtk224.GtkTextBuffer.property["text"]["__gencode__"] = {'gtk_text_buffer_set_text((GtkTextBuffer*){* id *}, (const gchar*){* property.value *}, (gint)-1)'}

----------------==  GtkTextChildAnchor
----------------==  GtkTextLayout
----------------==  GtkTextMark
----------------==  GtkTextTag
Gtk224.PatchGlibProperty(Gtk224.GtkTextTag);

----------------==  GtkTextTagTable
Gtk224.GtkTextTagTable.packing = {
    {
      -- 用于判断是否属于当前组
        group = {}, group_code = {
            { name = {},  gen_code = "gtk_text_tag_table_add((GtkTextTagTable*){* id *}, (GtkTextTag*){* child.id.value *})"},
        },
    },
};

----------------==  GtkTooltip
----------------==  GtkTreeModelFilter
Gtk224.GtkTreeModelFilter.constructor = { 
  -- 名称[- ==> _], 
  new = { gencode = "gtk_tree_model_filter_new((GtkTreeModel*)({* this.child_model.value *}), (GtkTreePath*)({* this.virtual_root.value *}))", 
          params = { type = {"GtkTreeModel*", "GtkTreePath*"}, name = {"child_model", "virtual_root"} } },
};
Gtk224.GtkTreeModelFilter.property.child_model.is_top_widget = true;
Gtk224.GtkTreeModelFilter.property.child_model.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTreeModelFilter.property.virtual_root.__default__ = "NULL";

----------------==  GtkTreeModelSort
Gtk224.GtkTreeModelSort.constructor = { 
  -- 名称[- ==> _], 
  new = { gencode = "gtk_tree_model_sort_new_with_model((GtkTreeModel*)({* this.model.value *}) )", 
          params = { type = {"GtkTreeModel*"}, name = {"model"} } },
};

----------------==  GtkTreeSelection
Gtk224.GtkTreeSelection.constructor = {     -- 名称[- ==> _],
    new = { gencode = "gtk_tree_view_get_selection((GtkTreeView*) {* parent.property.id.value *})", 
            params = { type = {}, name = {} } },
};

----------------==  GtkTreeStore
-- GtkTreeStore的第一个属性是column_0，然后是column_1，column_2，...，最后以column_count结尾
-- 这里利用了生成属性代码中使用Gtkui.pairs对属性进行了排序的特性
Gtk224.GtkTreeStore.property["column_0"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"static GType __{*id*}_gtypes__[{* property.value *} + 1] = { //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk224.GtkTreeStore.property["^column_%d+$"] = {__type__="GType*", regex = true,
                      __gencode__ = {"    {* Gtkui.GlibBaseTypeToGType(property.value) *}, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk224.GtkTreeStore.property["column_count"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"G_TYPE_INT}",
                                     "gtk_tree_store_set_column_types((GtkTreeStore*){* id *}, (gint){* property.value *}, __{*id*}_gtypes__)"}};
-- GtkTreeStore的构建函数
--GtkTreeStore.constructor["new"] = { gencode = "gtk_tree_store_new((gint)({* this.n_columns.value *}),{% for idx=1,this.n_columns.value do %}G_TYPE_INT, {% end %} G_TYPE_INT)", 
--                                       params = { type = {"gint"}, name = {"n_columns"} } };
Gtk224.GtkTreeStore.constructor["new"] = { gencode = "gtk_tree_store_new((gint)(1), G_TYPE_INT)",
                                       params = { type = {}, name = {} } };
Gtk224.GtkTreeStore.constructor["newv"] = nil;

----------------==  GtkUIManager
Gtk224.GtkUIManager.child_property = { 
    -- 属性名称  属性类型 缺省值
    ui        = {__type__="gboolean"},
    parent_id = {__type__="GtkUIManager*"},
};
Gtk224.GtkUIManager.packing = {
    {
        group = {"ui"}, group_code = { { name = {"ui"},  
        gen_code = "gtk_ui_manager_add_ui_from_string((GtkUIManager*){* id *}, (const gchar*){* child.id.value *}, -1, NULL)"},},
    },
    {
        group = {}, group_code = { { name = {},
        gen_code = "gtk_ui_manager_insert_action_group((GtkUIManager*){* id *}, ({* child.class.value *}*){* child.id.value *}, 0)"},},
    },
};
Gtk224.GtkUIManagerChildUI = {
    class = "GtkUIManagerChildUI", 
    constructor = { 
      -- 名称[- ==> _], 
      new = { gencode = "{* this.merge_id.value *}", params = { type = {"gchar*"}, name = {"merge_id"} } },
    },
    signal = { 
      -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    },
    property = { 
      -- 属性名称  属性类型 缺省值 代码生成
      merge_id = {__type__="gchar*", macro_code = {uiheaders = "GTK_UI_MANAGER_CHILD_UI_DEFINE"}},
    },
    parent = nil, 
};

----------------==  GtkWindowGroup
----------------==  GtkAdjustment
----------------==  GtkCellRenderer
Gtk224.GtkCellRenderer.property["__group__"] = {
  {
      -- 用于判断是否属于当前组
      group = {"xalign", "yalign"},
      -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
      group_code = {
          {name = {"xalign", "yalign"}, gen_code = "gtk_cell_renderer_set_alignment((GtkCellRenderer*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *})" },
      }
  },
  {
      -- 用于判断是否属于当前组
      group = {"xpad", "ypad"},
      -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
      group_code = {
          {name = {"xpad", "ypad"}, gen_code = "gtk_cell_renderer_set_padding((GtkCellRenderer*){* id *}, (gint){* this.xpad.value *}, (gint){* this.ypad.value *})" },
      }
  },
  {
    -- 用于判断是否属于当前组
    group = {"height", "width"},
    -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
    group_code = {
        {name = {"height", "width"}, gen_code = "gtk_cell_renderer_set_fixed_size((GtkCellRenderer*){* id *}, (gint){* this.height.value *}, (gint){* this.width.value *})" },
    }
  }
};

function Gtk224.PatchGtkCellRenderers(class)
    local function string_starts(String,Start)
        return string.sub(String,1,string.len(Start))==Start
    end
    local function string_ends(String,End)
        return End=='' or string.sub(String,-string.len(End))==End
    end
    -- 传入类实例，直接进行Patch操作
    if class.property ~= nil then
        for prop_name, property in pairs(class.property) do
            -- 跳过特殊字段
            if (not string_starts(prop_name, "__")) or (not string_ends(prop_name, "__")) then
                local real_prop_name = string.gsub(prop_name, "_", "-")
                -- 如果生成代码为空
                if property.__gencode__ == nil then
                    property.__gencode__ = {"g_object_set(G_OBJECT ({* id *}), \"" .. 
                                              real_prop_name .. "\", (".. property.__type__ .. ")({* property.value *}), NULL)"}
                end
            end
        end
    end
end

Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRenderer);
Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRendererAccel);
Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRendererCombo);
Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRendererPixbuf);
Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRendererProgress);
Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRendererSpinner);
Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRendererText);
Gtk224.PatchGtkCellRenderers(Gtk224.GtkCellRendererToggle);
-- 打完补丁后，这个函数就不需要了
Gtk224.PatchGtkCellRenderers = nil;

----------------==  GtkFileFilter
----------------==  GtkIMContextSimple
----------------==  GtkIMMulticontext
----------------==  GtkItemFactory
----------------==  GtkRecentAction
Gtk224.GtkRecentAction.constructor.new_for_manager = nil;

----------------==  GtkRecentFilter
----------------==  GtkToggleAction
----------------==  GtkTooltips
----------------==  GtkTreeViewColumn
-- ，需要删除new_with_attributes构造函数，分步构造
Gtk224.GtkTreeViewColumn.constructor.new_with_attributes = nil;
-- 添加一个expand的子属性
Gtk224.GtkTreeViewColumn.child_property = {expand = {__type__="gboolean" ,__default__ = "FALSE" }};
Gtk224.GtkTreeViewColumn["packing"] = {
  {
      -- 用于判断是否属于当前组
      group = {}, group_code = { { name = {"expand"},  
          gen_code = "gtk_tree_view_column_pack_start((GtkTreeViewColumn*){* id *}, (GtkCellRenderer*){* child.id.value *}, {* packing.expand.value *})"},
      },
  },
};

----------------==  GtkWidget
Gtk224.GtkWidget.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"width_request", "height_request"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = { {name = {"width_request", "height_request"}, 
            gen_code = "gtk_widget_set_size_request((GtkWidget*){* id *}, {* this.width_request.value *}, {* this.height_request.value *})" },
        }
    },
};

-- 部分子控件，如GtkMessageDialog之类需要parent参数
Gtk224.GtkWidget.property["parent"]["__default__"] = "NULL"

-- GtkWidget的has_default属性对应的代码生成函数
Gtk224.GtkWidget.property["has_default"]["__gencode__"] = {"({* property.value *}) ? gtk_widget_grab_default((GtkWidget*)({* id *})) : (void)0"};
Gtk224.GtkWidget.property["has_focus"]["__gencode__"] = {"({* property.value *}) ? gtk_widget_grab_focus((GtkWidget*)({* id *})) : (void)0"};
Gtk224.GtkWidget.property["is_focus"]["__gencode__"] = {"({* property.value *}) ? gtk_widget_grab_focus((GtkWidget*)({* id *})) : (void)0"};

----------------==  GtkCalendar
Gtk224.PatchGlibProperty(Gtk224.GtkCalendar);

----------------==  GtkCellRendererPixbuf
----------------==  GtkCellRendererProgress
----------------==  GtkCellRendererSpinner
----------------==  GtkCellRendererText
----------------==  GtkCellRendererToggle
----------------==  GtkCellView
-- 这个属性允许为NULL，对应宏名为GET_GDK_COLOR2
Gtk224.GtkCellView.property["background"]["__gencode__"] = {"gtk_cell_view_set_background_color((GtkCellView*)({* id *}, (const GdkColor*)({* property.value *}))"};
Gtk224.GtkCellView.property["background_gdk"]["__gencode__"] = {"gtk_cell_view_set_background_color((GtkCellView*)({* id *}, (const GdkColor*)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkCellView, {"background_set"});

----------------==  GtkContainer
-- GtkContainer的child property属性生成代码
Gtk224.GtkContainer["packing"] = {
    {
        group = {}, group_code = { { name = {}, 
            gen_code = "gtk_container_add((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *})"}},
    },
};

----------------==  GtkDrawingArea
----------------==  GtkEntry
-- GtkEntry的构造函数
Gtk224.GtkEntry.constructor["new_with_max_length"] = {  gencode = "gtk_entry_new_with_max_length((gint)({* this.max_length.value *}))",
													params = { type = {"gint"}, name = {"max_length"} } };
-- GtkEntry的属性
Gtk224.GtkEntry.property["invisible_char"]["__type__"]                      = "gunichar";
Gtk224.GtkEntry.property["xalign"]["__gencode__"]                           = {"gtk_entry_set_alignment((GtkEntry*){* id *}, (gfloat){* property.value *})"};
-- Gtk224.GtkEntry.property["cursor_position"]["__gencode__"]                  = {"gtk_editable_set_position((GtkEditable*){* id *}, (gint){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_activatable"]["__gencode__"]         =  {"gtk_entry_set_icon_activatable((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (gboolean){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_gicon"]["__gencode__"]               =  {"gtk_entry_set_icon_from_gicon((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (GIcon*){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_name"]["__gencode__"]                =  {"gtk_entry_set_icon_from_icon_name((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_pixbuf"]["__gencode__"]              =  {"gtk_entry_set_icon_from_pixbuf((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (GdkPixbuf*){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_sensitive"]["__gencode__"]           =  {"gtk_entry_set_icon_sensitive((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (gboolean){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_stock"]["__gencode__"]               =  {"gtk_entry_set_icon_from_stock((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_tooltip_markup"]["__gencode__"]      =  {"gtk_entry_set_icon_tooltip_markup((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk224.GtkEntry.property["primary_icon_tooltip_text"]["__gencode__"]        =  {"gtk_entry_set_icon_tooltip_text((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_activatable"]["__gencode__"]       =  {"gtk_entry_set_icon_activatable((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (gboolean){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_gicon"]["__gencode__"]             =  {"gtk_entry_set_icon_from_gicon((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (GIcon*){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_name"]["__gencode__"]              =  {"gtk_entry_set_icon_from_icon_name((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_pixbuf"]["__gencode__"]            =  {"gtk_entry_set_icon_from_pixbuf((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (GdkPixbuf*){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_sensitive"]["__gencode__"]         =  {"gtk_entry_set_icon_sensitive((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (gboolean){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_stock"]["__gencode__"]             =  {"gtk_entry_set_icon_from_stock((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_tooltip_markup"]["__gencode__"]    =  {"gtk_entry_set_icon_tooltip_markup((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
Gtk224.GtkEntry.property["secondary_icon_tooltip_text"]["__gencode__"]      =  {"gtk_entry_set_icon_tooltip_text((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
Gtk224.PatchGlibProperty(Gtk224.GtkEntry, {"caps_lock_warning", "invisible_char_set", "shadow_type", "truncate_multiline"});

----------------==  GtkHSV
----------------==  GtkInvisible
----------------==  GtkMisc

-- GtkMisc的组合属性
Gtk224.GtkMisc.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"xalign", "yalign"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"xalign", "yalign"}, gen_code = "gtk_misc_set_alignment((GtkMisc*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *})" },
        }
    },
    {
        -- 用于判断是否属于当前组
        group = {"xpad", "ypad"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"xpad", "ypad"}, gen_code = "gtk_misc_set_padding((GtkMisc*){* id *}, (gint){* this.xpad.value *}, (gint){* this.ypad.value *})" },
        }
    },
};

----------------==  GtkOldEditable
----------------==  GtkPreview
----------------==  GtkProgress
-- GtkProgress的组合属性
Gtk224.GtkProgress.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"text_xalign", "text_yalign"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"text_xalign", "text_yalign"}, gen_code = {"gtk_progress_set_text_alignment((GtkProgress*){* id *}, (gfloat){* this.text_xalign.value *}, (gfloat){* this.text_yalign.value *})" }},
        }
    },
};

----------------==  GtkRadioAction
Gtk224.GtkRadioAction.property.group.__gencode__ = {"gtk_radio_action_set_group((GtkRadioAction*)({* id *}), (GSList*)gtk_radio_action_get_group({* property.value *}))"};
Gtk224.GtkRadioAction.property.value["__gencode__"] = {"gtk_radio_action_set_current_value((GtkRadioAction*)({* id *}), (gint){* property.value *})"};

----------------==  GtkRange
Gtk224.GtkRange.property.adjustment.__default__ = "NULL";

----------------==  GtkRuler
-- GtkRuler的组合属性
Gtk224.GtkRuler.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"lower", "upper", "position", "max_size"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            { name = {"lower", "upper", "position", "max_size"}, 
              gen_code = "gtk_ruler_set_range((GtkRuler*){* id *}, (gdouble){* this.lower.value *}, (gdouble){* this.upper.value *}, (gdouble){* this.position.value *}, (gdouble){* this.max_size.value *})" },
        }
    },
};

----------------==  GtkSeparator
----------------==  GtkArrow
-- GtkArrow的arrow_type、shadow_type属性属于必选
Gtk224.GtkArrow.property["arrow_type"]["__construct__"] = 1
Gtk224.GtkArrow.property["shadow_type"]["__construct__"] = 1

----------------==  GtkBin
----------------==  GtkBox
-- GtkBox的child property属性生成代码
Gtk224.GtkBox["packing"] = {
    {
      -- 用于判断是否属于当前组，默认pack_type为gtk_box_pack_start，当有pack_type时，通常就是gtk_box_pack_end
      group = {"pack_type"}, group_code = {
          { name = {"expand", "fill", "padding", "pack_type"}, filter_out = {"position"}, 
            gen_code = "gtk_box_pack_end((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
      },
    }, 
    {
      -- 全空的名称，则永远都会匹配到
      group = {}, group_code = {
          { name = {"expand", "fill", "padding"}, filter_out = {"position"}, 
            gen_code = "gtk_box_pack_start((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"},
          -- 一般也不需要配置position
          --{ name = {"position"}, 
          --  gen_code = "gtk_box_reorder_child((GtkBox*)gtk_dialog_get_action_area((GtkDialog*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.position.value *})"}
      },
    },
};

----------------==  GtkCList
Gtk224.GtkCList.constructor.new = { gencode = "gtk_clist_new((gint)({* this.n_columns.value *}))", 
                                  params = { type = {"guint"}, name = {"n_columns"} } }
Gtk224.GtkCList.constructor.new_with_titles = nil;
Gtk224.PatchGlibProperty(Gtk224.GtkCList, {"titles_active"});

----------------==  GtkCellRendererAccel
----------------==  GtkCellRendererCombo
----------------==  GtkCellRendererSpin
----------------==  GtkCurve
-- GtkCurve的组合属性
Gtk224.GtkCurve.property["__group__"] = {
  {
	  -- 用于判断是否属于当前组
	  group = {"min_x", "min_y", "max_x", "max_y"},
	  -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
	  group_code = {
		  {name = {"min_x", "min_y", "max_x", "max_y"}, gen_code = "gtk_curve_set_range((GtkCurve*){* id *}, (gfloat){* this.min_x.value *}, (gfloat){* this.max_x.value *}, (gfloat){* this.min_y.value *}, (gfloat){* this.max_y.value *})" },
	  }
  },
};

----------------==  GtkFixed
-- GtkFixed的child property属性生成代码
Gtk224.GtkFixed["packing"] = {
    {
        -- 用于判断是否属于当前组
        -- 正常情况下，都会有x与y的，除非x、y = 0
        group = {}, group_code = { { name = {"x", "y"}, 
            gen_code = "gtk_fixed_put((GtkFixed*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.x.value *}, {* packing.y.value *})"}
        },
    },
};

----------------==  GtkHRuler
----------------==  GtkHSeparator
----------------==  GtkIconView
----------------==  GtkImage
-- GtkImage的构建函数，需要全部重新打patch
Gtk224.GtkImage.constructor = {
    -- 名称[- ==> _]， 
    new                = {  gencode = "gtk_image_new()", 
                            params = { type = {}, name = {} } },
    new_from_animation = {  gencode = "gtk_image_new_from_animation((GdkPixbufAnimation*)({* this.pixbuf_animation.value *}))", 
                            params = { type = {"GdkPixbufAnimation*"}, name = {"pixbuf_animation"} } },
    new_from_file_utf8 = { gencode = "gtk_image_new_from_file_utf8((GdkPixbufAnimation*)({* this.file.value *}))", 
                            params = { type = {"gchar*"}, name = {"file"} } },
    new_from_gicon     = { gencode = "gtk_image_new_from_gicon((GIcon*)({* this.gicon.value *}), (GtkIconSize)({* this.icon_size.value *}))",
                            params = { type = {"GIcon*", "gint"}, name = {"gicon", "icon_size"} } },
    new_from_icon_name = { gencode = "gtk_image_new_from_gicon((GIcon*)({* this.icon_name.value *}), (GtkIconSize)({* this.icon_size.value *}))", 
                            params = { type = {"const gchar*", "gint"}, name = {"icon_name", "icon_size"} } },
    new_from_icon_set  = { gencode = "gtk_image_new_from_icon_set((GtkIconSet*)({* this.icon_set.value *}), (GtkIconSize)({* this.icon_size.value *}))", 
                            params = { type = {"GtkIconSet*", "gint"}, name = {"icon_set", "icon_size"} } },
    new_from_image     = { gencode = "gtk_image_new_from_image((GdkImage*)({* this.image.value *}), (GdkBitmap*)({* this.mask.value *}))", 
                            params = { type = {"GdkImage*", "GdkBitmap*"}, name = {"image", "mask"} } },
    new_from_stock     = { gencode = "gtk_image_new_from_stock((const gchar*)({* this.stock.value *}), (GtkIconSize)({* this.icon_size.value *}))", 
                            params = { type = {"gchar*", "gint"}, name = {"stock", "icon_size"} } },
    new_from_pixbuf    = { gencode = "gtk_image_new_from_pixbuf((GdkPixbuf*)GET_GDK_PIX_BUF({* this.pixbuf.value *}))", 
                            params = { type = {"GdkPixbuf*"}, name = {"pixbuf"} } },
};

-- GtkImage的属性设置接口
Gtk224.GtkImage.property["gicon"]["__need_more__"] = {"icon_size"};       -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk224.GtkImage.property["icon_name"]["__need_more__"] = {"icon_size"};   -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk224.GtkImage.property["icon_set"]["__need_more__"] = {"icon_size"};    -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk224.GtkImage.property["stock"]["__need_more__"] = {"icon_size"};       -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk224.GtkImage.property["gicon"]["__gencode__"]     = {"gtk_image_set_from_gicon((GtkImage*)({* id *}), (GIcon*)({* property.value *}), (GtkIconSize)({* this.icon_size.value *}))"};
Gtk224.GtkImage.property["icon_name"]["__gencode__"] = {"gtk_image_set_from_icon_name((GtkImage*)({* id *}), (const gchar*)({* property.value *}), (GtkIconSize)({* this.icon_size.value *}))"};
Gtk224.GtkImage.property["icon_set"]["__gencode__"]  = {"gtk_image_set_from_icon_set((GtkImage*)({* id *}), (GtkIconSet*)({* property.value *}), (GtkIconSize)({* this.icon_size.value *}))"};
Gtk224.GtkImage.property["stock"]["__gencode__"]     = {"gtk_image_set_from_stock((GtkImage*){* id *}, (gchar*){* property.value *}, (GtkIconSize){* this.icon_size.value *})"};

Gtk224.GtkImage.property["image"]["__need_more__"] = {"mask"}; -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk224.GtkImage.property["pixmap"]["__need_more__"] = {"mask"}; -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk224.GtkImage.property["image"]["__gencode__"]     = {"gtk_image_set_from_image((GtkImage*)({* id *}), (GdkImage*)({* property.value *}), (GdkBitmap*)({* this.mask.value *}))"};
Gtk224.GtkImage.property["pixmap"]["__gencode__"]    = {"gtk_image_set_from_pixmap((GtkImage*)({* id *}), (GdkPixmap*)({* property.value *}), (GdkBitmap*)({* this.mask.value *}))"};

Gtk224.GtkImage.property["pixbuf_animation"]["__gencode__"]    = {"gtk_image_set_from_animation((GtkImage*)({* id *}), (GdkPixbufAnimation*)({* property.value *}))"};

----------------==  GtkLabel
-- GtkLabel的构建函数
Gtk224.GtkLabel.constructor["new"]                = { gencode = "gtk_label_new((const gchar*)({* this.label.value *}))",
                                                    params = { type = {"gchar*"}, name = {"label"} } };
Gtk224.GtkLabel.constructor["new_with_mnemonic"]  = { gencode = "gtk_label_new_with_mnemonic((const gchar*)({* this.label.value *}))",
                                                    params = { type = {"gchar*", "gboolean"}, name = {"label", "use_underline"} } };

Gtk224.GtkLabel.property.wrap["__gencode__"] = {"gtk_label_set_line_wrap((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"}
Gtk224.GtkLabel.property.wrap_mode["__gencode__"] = {"gtk_label_set_line_wrap_mode((GtkLabel*)({* id *}), (PangoWrapMode)({* property.value *}))"}

-- GtkLabel的第一个Pango属性是pango_attr_0_start，然后是pango_attr_XXX 最后以pango_attr_z_end结尾
-- 这里利用了生成属性代码中使用Gtkui.pairs对属性进行了排序的特性
Gtk224.GtkLabel.property["pango_attr_0_start"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"{ //",
                                     "    PangoAttribute* _{* id *}_pango_attr = NULL",
                                     "    PangoAttrList*  _{* id *}_pango_attr_list = pango_attr_list_new()"}
};
Gtk224.GtkLabel.property["^pango_attr_[%-%l]+_1_start$"] = {__type__="guint", __default__ = "0", regex = true,
                      __gencode__ = {"    _{* id *}_pango_attr->start_index = {* property.value *}"}
};
Gtk224.GtkLabel.property["^pango_attr_[%-%l]+_2_end$"] = {__type__="guint", __default__ = "4294967295", regex = true,
                      __gencode__ = {"    _{* id *}_pango_attr->end_index = {* property.value *}"}
};
Gtk224.GtkLabel.property["^pango_attr_[%-%l]+_3_value$"] = {__type__="guint", regex = true,
                      __gencode__ = {"    pango_attr_list_insert (_{* id *}_pango_attr_list, _{* id *}_pango_attr)"}
};

Gtk224.GtkLabel.property["pango_attr_language_0_value"] = {__type__="gchar*",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_language_new((PangoLanguage)(pango_language_from_string({* property.value *})))",}
};
Gtk224.GtkLabel.property["pango_attr_style_0_value"] = {__type__="PangoStyle",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_style_new((PangoStyle)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_weight_0_value"] = {__type__="PangoWeight",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_weight_new((PangoWeight)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_variant_0_value"] = {__type__="PangoVariant",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_variant_new((PangoVariant)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_stretch_0_value"] = {__type__="PangoStretch",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_stretch_new((PangoStretch)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_underline_0_value"] = {__type__="gboolean",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_underline_new((PangoUnderline)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_strikethrough_0_value"] = {__type__="gboolean",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_strikethrough_new((gboolean)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_gravity_0_value"] = {__type__="PangoGravity",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_gravity_new((PangoGravity)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_gravity-hint_0_value"] = {__type__="PangoGravityHint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_gravity_hint_new((PangoGravityHint)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_family_0_value"] = {__type__="gchar*",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_family_new((const gchar*)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_size_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_size_new({* property.value *})"}
};
Gtk224.GtkLabel.property["pango_attr_absolute-size_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_size_new_absolute({* property.value *})"}
};
Gtk224.GtkLabel.property["pango_attr_font_desc_0_value"] = {__type__="gchar*",
                      __gencode__ = {"    { //","        PangoFontDesc* _font_desc = pango_font_description_from_string({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_font_desc_new(_font_desc)",
                                     "        pango_font_description_free(_font_desc)","    } //"}
};
Gtk224.GtkLabel.property["pango_attr_foreground_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ","        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_foreground_new(color->red, color->green, color->blue)","    } //"}
};
Gtk224.GtkLabel.property["pango_attr_background_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ", "        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_background_new(color->red, color->green, color->blue)", "    } //"}
};
Gtk224.GtkLabel.property["pango_attr_underline-color_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ", "        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_underline_color_new(color->red, color->green, color->blue)", "    } //"}
};
Gtk224.GtkLabel.property["pango_attr_strikethrough-color_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ", "        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_strikethrough_color_new(color->red, color->green, color->blue)", "    } //"}
};
Gtk224.GtkLabel.property["pango_attr_scale_0_value"] = {__type__="gdouble",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_scale_new((gdouble)({* property.value *}))"}
};
Gtk224.GtkLabel.property["pango_attr_z_end"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"    gtk_label_set_attributes((GtkLabel*)({* id *}), (PangoAttrList*)(_{* id *}_pango_attr_list))",
                                     "    pango_attr_list_unref(_{* id *}_pango_attr_list)", "} //"}
};

----------------==  GtkLayout
-- GtkLayout的child property属性生成代码
Gtk224.GtkLayout["packing"] = {
    {
        -- 用于判断是否属于当前组
        -- 正常情况下，都会有x与y的，除非x、y = 0
        group = {},  group_code = { {name = {"x", "y"}, 
            gen_code = "gtk_layout_put((GtkLayout*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.x.value *}, {* packing.y.value *})"}},
    },
};

-- GtkLayout的property属性生成代码
Gtk224.GtkLayout.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"height", "width"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"height", "width"}, gen_code = "gtk_layout_set_size((GtkWidget*){* id *}, {* this.width.value *}, {* this.height.value *})" },
        }
    },
};

----------------==  GtkList
---- 如果是Gtk.Combo中的entry，应该直接访问变量方式取得
Gtk224.GtkList.property["is_inter_child_in_combo"] = {__type__="gboolean" ,__default__ = "TRUE", __construct__= 1 };
Gtk224.GtkList.constructor.new_from_inter_child_in_combo = { gencode = "((GtkCombo*)({* parent.property.id.value *})->list", 
                                                     params = { type = {"gboolean"}, name = {"is_inter_child_in_combo"} } };

----------------==  GtkMenuShell
Gtk224.GtkMenuShell["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {},  group_code = { {name = {}, 
            gen_code = "gtk_menu_shell_append((GtkMenuShell*){* id *}, (GtkWidget*){* child.id.value *})"}},
    },
};

----------------==  GtkNotebook
-- GtkNotebook的child property属性生成代码，根据child property属性来判断调用哪一句话生成代码
Gtk224.GtkNotebook["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {}, can_skip = true, gen_code = "" , 
            filter_out = {"detachable", "menu_label", "position", "reorderable", "tab_expand", "tab_fill", "tab_pack", "tab_label"}}},
    },
};
Gtk224.GtkNotebook.property.enable_popup.__gencode__ = {"g_object_set((GObject*){* id *}, \"enable-popup\", (gboolean){* property.value *}, NULL)"};
Gtk224.GtkNotebook.property.homogeneous.__gencode__ = {"gtk_notebook_set_homogeneous_tabs((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))";};
  
---------------------  GtkNotebookLabel，包装用于处理GtkNotebook的处理
Gtk224.GtkNotebookLabel = {
    class = "GtkNotebookLabel",
    -- 直接套用GtkLabel的构造函数
    constructor = Gtk224.GtkLabel.constructor,
    signal = { 
        -- 信号名称[- ==> _]， 信号返回值, 信号参数列表
    },
    property = {
    },
    -- 直接拷贝GtkNotebook的子属性
    child_property = Gtk224.table_copy_table_in_patch(Gtk224.GtkNotebook.child_property),
    packing = {
        { group = {"parent_id"}, group_code = { { name = {"parent_id"},                     
              gen_code = "gtk_notebook_append_page((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, (GtkWidget*){* id *})"}}
        },
        { group = {"detachable"}, group_code = { { name = {"detachable"}, 
              gen_code = "gtk_notebook_set_tab_detachable((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.detachable.value *})"}}
        },
        { group = {"menu_label"}, group_code = { { name = {"menu_label"}, 
            gen_code = "gtk_notebook_set_menu_label_text((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.menu_label.value *})"}}
        },
        { group = {"position"}, group_code = { { name = {"position"}, can_skip = true, gen_code = ""}}
        },
        { group = {"reorderable"}, group_code = { { name = {"reorderable"}, 
            gen_code = "gtk_notebook_set_tab_reorderable((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.reorderable.value *})"}}
        },
        { group = {}, group_code = { { name = {"tab_expand", "tab_fill", "tab_pack"}, can_skip = true,
            gen_code = "gtk_notebook_set_tab_label_packing((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.tab_expand.value *}, {* packing.tab_fill.value *}, {* packing.tab_pack.value *})"}}
        },
        { group = {"tab_label"}, group_code = { { name = {"tab_label"}, 
            gen_code = "gtk_notebook_set_tab_label_text((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, (const gchar *)({* packing.tab_label.value *})"}}
        },
    },
    parent = Gtk224.GtkLabel,
};

-- 添加一个子属性
Gtk224.GtkNotebookLabel.child_property.parent_id = {__type__="GtkNotebook*", __default__ = "NULL", macro_code = {uiheaders = "NOTEBOOK_LABEL_DEFINE"}};

----------------==  GtkPaned
-- GtkPaned的child property属性生成代码，根据child property属性来判断调用哪一句话生成代码
Gtk224.GtkPaned["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {"resize", "shrink"}, 
            gen_code = "(*((NULL == gtk_paned_get_child1((GtkPaned*){* id *})) ? &gtk_paned_pack1: &gtk_paned_pack2))((GtkPaned*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.resize.value *}, {* packing.shrink.value *})"}
        },
    },
};
Gtk224.PatchGlibProperty(Gtk224.GtkPaned, {"position_set"});

----------------==  GtkPixmap
----------------==  GtkProgressBar
Gtk224.PatchGlibProperty(Gtk224.GtkProgressBar, {"adjustment"});

----------------==  GtkScale
----------------==  GtkScrollbar
----------------==  GtkSocket
----------------==  GtkSpinButton
Gtk224.GtkSpinButton.constructor.new2 = {
    gencode = "gtk_spin_button_new((GtkAdjustment*)(NULL), (gdouble)(0), (guint)(0))", 
    params = { type = {}, name = {} }
};

Gtk224.GtkSpinButton.constructor.new_with_range = { 
    gencode = "gtk_spin_button_new_with_range((gdouble)gtk_adjustment_get_lower({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_upper({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_step_increment({* this.adjustment.value *}))", 
    params = { type = {"GtkAdjustment*"}, name = {"adjustment"}}
};

-- 默认adjustment属性为NULL
Gtk224.GtkSpinButton.property["adjustment"]["__default__"] = "NULL";

Gtk224.PatchGlibProperty(Gtk224.GtkSpinButton, {"climb_rate"});

----------------==  GtkSpinner
Gtk224.PatchGlibProperty(Gtk224.GtkSpinner, {"active"});
--Gtk224.GtkSpinner.property.active.__gencode__ = { "g_object_set((GObject*)({* id *}), \"active\", (gboolean)({* property.value *}), NULL)" };

----------------==  GtkTable
-- 需要patch GtkTable["constructor"]的new
Gtk224.GtkTable.constructor["new"] = { gencode = "gtk_table_new((guint)({* this.n_rows.value *}), (guint)({* this.n_columns.value *}), (gboolean)({* this.homogeneous.value *}))",
                                   params = { type = {"guint", "guint", "gboolean"}, name = {"n_rows", "n_columns", "homogeneous"} } };

-- 需要patch GtkTable_property的column_spacing
Gtk224.GtkTable.property["column_spacing"]["__gencode__"] = {'gtk_table_set_col_spacings((GtkTable*){* id *}, (guint){* property.value *})'}
Gtk224.GtkTable.property["row_spacing"]["__gencode__"]    = {'gtk_table_set_row_spacings((GtkTable*){* id *}, (guint){* property.value *})'}

Gtk224.GtkTable.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"n_rows", "n_columns"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"n_rows", "n_columns"}, gen_code = "gtk_table_resize((GtkTable*){* id *}, {* this.n_rows.value *}, {* this.n_columns.value *})" },
        }
    },
};

-- GtkTable的child property属性生成代码
Gtk224.GtkTable["packing"] = {
    {
        -- 用于判断是否属于当前组
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group = {}, group_code = {{ name = {"left_attach", "right_attach", "top_attach", "bottom_attach", "x_options", "y_options", "x_padding", "y_padding"}, 
            gen_code = "gtk_table_attach((GtkTable*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.left_attach.value *}, {* packing.right_attach.value *}, {* packing.top_attach.value *}, {* packing.bottom_attach.value *}, (GtkAttachOptions)({* packing.x_options.value *}), (GtkAttachOptions)({* packing.y_options.value *}), {* packing.x_padding.value *}, {* packing.y_padding.value *})"},
        }
    },
};

----------------==  GtkTextView
----------------==  GtkToolItemGroup
Gtk224.GtkToolItemGroup["packing"] = {
    {
        group = {"position"}, group_code = { { name = {"position"},  
            gen_code = "gtk_tool_item_group_insert((GtkToolItemGroup*){* id *}, (GtkToolItem*){* child.id.value *}, (gint)({* packing.position.value *}))"}},
    },
    {
        group = {"expand"}, group_code = { { name = {"expand"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"expand\", (gint)({* packing.expand.value *}), NULL)"}},
    },
    {
        group = {"fill"}, group_code = { { name = {"fill"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"fill\", (gint)({* packing.fill.value *}), NULL)"}},
    },
    {
        group = {"homogeneous"}, group_code = { { name = {"homogeneous"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"homogeneous\", (gint)({* packing.homogeneous.value *}), NULL)"}},
    },
    {
        group = {"new_row"}, group_code = { { name = {"new_row"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"new-row\", (gint)({* packing.new_row.value *}), NULL)"}},
    },
};

----------------==  GtkToolPalette
Gtk224.GtkToolPalette.property.toolbar_style.__gencode__ = {"gtk_tool_palette_set_style((GtkToolPalette*)({* id *}), (GtkToolbarStyle)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkToolPalette, {"icon_size_set"});
-- 拷贝Gtk224.GtkContainer的packing，然后再插入多条记录
Gtk224.GtkToolPalette.packing = Gtk224.copy_and_insert_more(Gtk224.GtkToolPalette.parent.packing,
    {
        group = {"exclusive"}, group_code = { { name = {"exclusive"}, 
            gen_code = "gtk_tool_palette_set_exclusive((GtkToolPalette*){* id *}, (GtkToolItemGroup*){* child.id.value *}, (gboolean)({* packing.exclusive.value *}))"}},
    },
    {
        group = {"expand"}, group_code = { { name = {"expand"}, 
            gen_code = "gtk_tool_palette_set_expand((GtkToolPalette*){* id *}, (GtkToolItemGroup*){* child.id.value *}, (gboolean)({* packing.expand.value *}))"}},
    }
);

----------------==  GtkToolbar
Gtk224.GtkToolbar.property.toolbar_style.__gencode__ = {"gtk_toolbar_set_style((GtkToolbar*)({* id *}), (GtkToolbarStyle)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkToolbar, {"icon_size_set"});
Gtk224.GtkToolbar.packing = {
    {
        group = {}, group_code = { { name = {}, 
            gen_code = "gtk_toolbar_insert((GtkToolbar*){* id *}, (GtkToolItem*){* child.id.value *}, -1)"}},
    },
    {
        group = {"homogeneous"}, group_code = { { name = {"homogeneous"}, 
            gen_code = "gtk_tool_item_set_homogeneous((GtkToolItem*){* id *}, (gboolean)({* packing.homogeneous.value *}))"}},
    },
    {
        group = {"expand"}, group_code = { { name = {"expand"}, 
            gen_code = "gtk_tool_item_set_expand((GtkToolItem*){* id *}, (gboolean)({* packing.expand.value *}))"}},
    },
};

----------------==  GtkTreeView
Gtk224.GtkTreeView.property["enable_grid_lines"]["__gencode__"] = {"gtk_tree_view_set_grid_lines((GtkTreeView*)({* id *}), (GtkTreeViewGridLines)({* property.value *}))"};
-- 添加一个子属性
Gtk224.GtkTreeView.child_property = { ["internal_child"] = {__type__="gchar*"   ,__default__ = "NULL"}};
Gtk224.GtkTreeView["packing"] = {
    {
        -- 如果是内部GtkTreeSelection，则不需要关联代码
        group = {"internal_child"}, group_code = { { name = {"internal_child"},  can_skip = true, gen_code = ""}},
    },
    {
        group = {}, group_code = { { name = {},  
            gen_code = "gtk_tree_view_append_column((GtkTreeView*){* id *}, (GtkTreeViewColumn*){* child.id.value *})"}},
    },
};

----------------==  GtkVRuler
----------------==  GtkVSeparator
----------------==  GtkAccelLabel
Gtk224.GtkAccelLabel.constructor.new = { gencode = "gtk_accel_label_new((const gchar*)({* this.label.value *}))", 
                                        params = { type = {"gchar*"}, name = {"label"} } };

----------------==  GtkAlignment
-- GtkAlignment的组合属性
Gtk224.PatchGlibProperty(Gtk224.GtkAlignment, {"xalign", "yalign", "xscale", "yscale"});
Gtk224.GtkAlignment.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"bottom_padding", "left_padding", "right_padding", "top_padding"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"bottom_padding", "left_padding", "right_padding", "top_padding"}, gen_code = "gtk_alignment_set_padding((GtkAlignment*){* id *}, (guint){* this.top_padding.value *}, (guint){* this.bottom_padding.value *}, (guint){* this.left_padding.value *}, (guint){* this.right_padding.value *})" },
        }
    },
};

----------------==  GtkButton
--- 添加完善GtkButton的三个属性的设置代码，用于某些特殊的internal-child场景
Gtk224.GtkButton.property.label.__gencode__ = {"gtk_button_set_label((GtkButton*)({* id *}), (const gchar*)({* property.value *}))"};
Gtk224.GtkButton.property.use_stock.__gencode__ = {"gtk_button_set_use_stock((GtkButton*)({* id *}), (gboolean)({* property.value *}))"};
Gtk224.GtkButton.property.use_underline.__gencode__ = {"gtk_button_set_use_underline((GtkButton*)({* id *}), (gboolean)({* property.value *}))"};
-- GtkButton的构建函数new_from_stock需要patch
Gtk224.GtkButton.constructor["new_from_stock"] = {  gencode = "gtk_button_new_from_stock((const gchar*)({* this.label.value *}))",
                                                params = { type = {"gchar*", "gboolean"}, name = {"label", "use_stock"} } };

-- GtkButton的构建函数new_with_mnemonic需要patch
Gtk224.GtkButton.constructor["new_with_mnemonic"] = {  gencode = "gtk_button_new_with_mnemonic((const gchar*)({* this.label.value *}))",
                                                params = { type = {"gchar*", "gboolean"}, name = {"label", "use_underline"} } };

-- GtkButton的组合属性
Gtk224.GtkButton.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group = {"xalign", "yalign"},
        group_code = {
            {name = {"xalign", "yalign"}, gen_code = "gtk_button_set_alignment((GtkButton*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *})" },
        }
    },
};

----------------==  GtkButtonBox
-- GtkButtonBox的layout_style属性对应的代码生成函数
Gtk224.GtkButtonBox.property["layout_style"]["__gencode__"] = {"gtk_button_box_set_layout((GtkButtonBox*)({* id *}), (GtkButtonBoxStyle)({* property.value *}))"};
-- 影子拷贝，然后再插入一项
Gtk224.GtkButtonBox.packing = Gtk224.copy_and_insert_more(Gtk224.GtkButtonBox.parent.packing,
    {
        group = {"secondary"}, group_code = { { name = {"secondary"}, 
            gen_code = "gtk_button_box_set_child_secondary((GtkButtonBox*){* id *}, (GtkWidget*){* child.id.value *}, (gboolean)({* packing.secondary.value *}))"}}
    }
);

----------------==  GtkCTree
Gtk224.GtkCTree.constructor.new = { gencode = "gtk_ctree_new((gint)({* this.n_columns.value *}), (gint)({* this.tree_column.value *}))", 
          params = { type = {"guint", "gint"}, 
                     name = {"n_columns", "tree_column"} } };
Gtk224.GtkCTree.constructor.new_with_titles = nil;

----------------==  GtkComboBox
Gtk224.GtkComboBox.child_property = { ["internal_child"] = {__type__="gchar*"   ,__default__ = "NULL"}};
--- 增加一个辅助类
Gtk224.GtkComboBoxChildEntry = {
  class = "GtkComboBoxChildEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_bin_get_child(GTK_BIN({* parent.property.id.value *}))", 
            params = { type = {"gboolean"}, name = {"internal_child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gboolean", macro_code = {uiheaders = "COMBOBOX_CHILD_ENTRY_DEFINE"}},
  },
  parent = Gtk224.GtkEntry,
};
-- GtkComboBox的构建函数new_text/new_with_entry/new_with_model_and_entry需要patch
Gtk224.GtkComboBox.packing = {
    {
        -- 如果是内部GtkEntry，则不需要关联代码
        group = {"internal_child"}, group_code = { { name = {"internal_child"}, can_skip = true, gen_code = ""}},
    },
};

Gtk224.GtkComboBox.constructor.new_text = nil;
Gtk224.GtkComboBox.constructor.new_with_model.params = { type = {"GtkTreeModel*"}, name = {"model"} };
Gtk224.GtkComboBox.constructor.new_with_entry.params = { type = {"gboolean"}, name = {"has_entry"} };
Gtk224.GtkComboBox.constructor.new_with_model_and_entry.params = { type = {"GtkTreeModel*", "gboolean"}, name = {"model", "has_entry"} };

Gtk224.GtkComboBox.property.tearoff_title.__gencode__ = {"gtk_combo_box_set_title((GtkComboBox*)({* id *}), (const gchar*)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkComboBox, {"has_frame"});

----------------==  GtkEventBox
----------------==  GtkExpander
Gtk224.GtkExpander.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use_underline"} }
Gtk224.GtkExpander.property.expanded.__gencode__ = {"gtk_expander_set_expanded((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"};
Gtk224.GtkExpander.property.use_markup.__gencode__ = {"gtk_expander_set_use_markup((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkExpander, {"label_fill"});

----------------==  GtkFrame
Gtk224.GtkFrame.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"label_xalign", "label_yalign"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"label_xalign", "label_yalign"}, gen_code = "gtk_frame_set_label_align((GtkFrame*){* id *}, (gfloat){* this.label_xalign.value *}, (gfloat){* this.label_yalign.value *})" },
        }
    },
};
Gtk224.GtkFrame.property.shadow.__gencode__ = Gtk224.GtkFrame.property.shadow_type.__gencode__;

----------------==  GtkHBox
----------------==  GtkHPaned
----------------==  GtkHScale
Gtk224.GtkHScale.constructor.new_with_range = nil

----------------==  GtkHScrollbar
----------------==  GtkHandleBox
Gtk224.GtkHandleBox.property.shadow.__gencode__ = Gtk224.GtkHandleBox.property.shadow_type.__gencode__;
Gtk224.PatchGlibProperty(Gtk224.GtkHandleBox, {"snap_edge_set"});

----------------==  GtkItem
----------------==  GtkMenu
Gtk224.GtkMenu.packing = {
    {
        -- 如果有如下四个参数的一个，则应该使用gtk_menu_attach关联
        group = {"bottom_attach", "left_attach", "right_attach", "top_attach"}, group_or_check=true, group_code = { { name = {"bottom_attach", "left_attach", "right_attach", "top_attach"}, 
            gen_code = "gtk_menu_attach((GtkMenu*){* id *}, (GtkWidget*)({* child.id.value *}), (gboolean)({* packing.left_attach.value *}), (gboolean)({* packing.right_attach.value *}), (gboolean)({* packing.top_attach.value *}), (gboolean)({* packing.bottom_attach.value *}))"},
        },
    }
    -- 否则会调用到GtkMenuShell的gtk_menu_shell_append
};
Gtk224.GtkMenu.property.tearoff_title.__gencode__ = {"gtk_menu_set_title((GtkMenu*)({* id *}), (const gchar*)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkMenu, {"attach_widget"});

----------------==  GtkMenuBar
----------------==  GtkScrolledWindow
Gtk224.GtkScrolledWindow.property.hadjustment.__default__ = "NULL";
Gtk224.GtkScrolledWindow.property.vadjustment.__default__ = "NULL";
Gtk224.GtkScrolledWindow.property.window_placement.__gencode__ = {"gtk_scrolled_window_set_placement((GtkScrolledWindow*){* id *}, (GtkCornerType)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkScrolledWindow, {"window_placement_set"});
Gtk224.GtkScrolledWindow.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"hscrollbar_policy", "vscrollbar_policy"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"hscrollbar_policy", "vscrollbar_policy"}, gen_code = "gtk_scrolled_window_set_policy((GtkScrolledWindow*){* id *}, (GtkPolicyType){* this.hscrollbar_policy.value *}, (GtkPolicyType){* this.vscrollbar_policy.value *})" },
        }
    },
};

----------------==  GtkTipsQuery
Gtk224.GtkTipsQuery.property["__group__"] = {
  {
      -- 用于判断是否属于当前组
      group = {"label_inactive", "label_no_tip"},
      -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
      group_code = {
          {name = {"label_inactive", "label_no_tip"}, gen_code = "gtk_tips_query_set_labels((GtkTipsQuery*){* id *}, (const gchar*){* this.label_inactive.value *}, (const gchar*){* this.label_no_tip.value *})" },
      }
  },
};
Gtk224.PatchGlibProperty(Gtk224.GtkTipsQuery, {"emit_always"});

----------------==  GtkToolItem
----------------==  GtkVBox
----------------==  GtkVPaned
----------------==  GtkVScale
Gtk224.GtkVScale.constructor.new_with_range = nil

----------------==  GtkVScrollbar
----------------==  GtkViewport
Gtk224.GtkViewport.property.hadjustment.__default__ = "NULL";
Gtk224.GtkViewport.property.vadjustment.__default__ = "NULL";

----------------==  GtkWindow
Gtk224.GtkWindow.property["^z_accel_group_%d+$"] = {__type__="GtkAccelGroup*", regex = true, 
                is_top_widget = true, ext_depend = true, macro_code = {uisources = "TOP_WIDGET"},
                __gencode__ = {"gtk_window_add_accel_group((GtkWindow*){* id *}, (GtkAccelGroup*)({* property.value *}))"}};
Gtk224.GtkWindow.property.window_position.__gencode__ = {"gtk_window_set_position((GtkWindow*)({* id *}), (GtkWindowPosition)({* property.value *}))"};
Gtk224.GtkWindow.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"allow_grow", "allow_shrink"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = { {name = {"allow_grow", "allow_shrink"}, 
            gen_code = "gtk_window_set_policy((GtkWindow*){* id *}, (gboolean){* this.allow_shrink.value *}, (gboolean){* this.allow_grow.value *}, TRUE)" },
        }
    },
    {
        -- 用于判断是否属于当前组
        group = {"default_height", "default_width"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = { {name = {"default_height", "default_width"}, 
            gen_code = "gtk_window_set_default_size((GtkWindow*){* id *}, (gint){* this.default_width.value *}, (gint){* this.default_height.value *})" },
        }
    },
};

----------------==  GtkAspectFrame
Gtk224.GtkAspectFrame.property["__group__"] = {
  {
      -- 用于判断是否属于当前组
      group = {"xalign", "yalign", "ratio", "obey_child"},
      -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
      group_code = { {name = {"xalign", "yalign", "ratio", "obey_child"}, 
          gen_code = "gtk_aspect_frame_set((GtkAspectFrame*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *}, (gfloat){* this.ratio.value *}, (gboolean){* this.obey_child.value *})" },
      }
  },
};

----------------==  GtkAssistant
-- GtkAssistant的child property属性生成代码
Gtk224.GtkAssistant["packing"] = {
    {
        group = {}, group_code = { { name = {}, 				                          
            gen_code = "gtk_assistant_append_page((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *})"}}
    },
    {
        group = {"complete"}, group_code = { { name = {"complete"},
            gen_code = "gtk_assistant_set_page_complete((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (gboolean){* packing.complete.value *})"}}
    },
    {
        group = {"header_image"}, group_code = { { name = {"header_image"},
            gen_code = "gtk_assistant_set_page_header_image((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (GdkPixbuf*){* packing.header_image.value *})"}}
    },
    {
        group = {"page_type"}, group_code = { { name = {"page_type"},
            gen_code = "gtk_assistant_set_page_type((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (GtkAssistantPageType){* packing.page_type.value *})"}}
    },
    {
        group = {"sidebar_image"}, group_code = { { name = {"sidebar_image"},
            gen_code = "gtk_assistant_set_page_side_image((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (GdkPixbuf*){* packing.sidebar_image.value *})"}}
    },
    {
        group = {"title"}, group_code = { { name = {"title"},
            gen_code = "gtk_assistant_set_page_title((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (const gchar*){* packing.title.value *})"}}
    }
};

----------------==  GtkColorButton
----------------==  GtkColorSelection
----------------==  GtkCombo
Gtk224.GtkCombo.child_property = { ["internal_child"] = {__type__="gchar*"   ,__default__ = "NULL"}};

Gtk224.GtkCombo.property["enable_arrow_keys"]["__gencode__"] = {"gtk_combo_set_use_arrows((GtkCombo*)({* id *}), (gboolean)({* property.value *}))"};
Gtk224.GtkCombo.property["enable_arrows_always"]["__gencode__"] = {"gtk_combo_set_use_arrows_always((GtkCombo*)({* id *}), (gboolean)({* property.value *}))"};
Gtk224.PatchGlibProperty(Gtk224.GtkCombo, {"allow_empty"});

--- 增加一个辅助类
Gtk224.GtkComboChildEntry = {
  class = "GtkComboChildEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "((GtkCombo*)({* parent.property.id.value *})->entry", 
            params = { type = {"gboolean"}, name = {"internal_child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gboolean", macro_code = {uiheaders = "COMBO_CHILD_ENTRY_DEFINE"}},
  },
  parent = Gtk224.GtkEntry,
};
Gtk224.GtkCombo.packing = {
  {
      -- 如果是内部GtkEntry，则不需要关联代码
      group = {"internal_child"}, group_code = { { name = {"internal_child"},  gen_code = ""}},
  },
};

----------------==  GtkComboBoxEntry
-- 需要删除GtkComboBoxEntry的构建函数new_text
Gtk224.GtkComboBoxEntry.constructor.new_text = nil;

----------------==  GtkComboBoxText
-- GtkComboBoxText的构建函数new_with_entry需要patch
Gtk224.GtkComboBoxText.constructor.new_with_entry.params = { type = {"gboolean"}, name = {"has_entry"} };
---  GtkComboBoxText，需要增加一个正则属性处理
Gtk224.GtkComboBoxText.property["^text_item_%d+$"] = {__type__="gchar*", regex = true,
                              __gencode__ = {"gtk_combo_box_text_append_text((GtkComboBoxText*){* id *}, (gchar*){* property.value *})"}};

----------------==  GtkDialog
Gtk224.GtkDialog.constructor.new_with_buttons = nil;
Gtk224.GtkDialog.child_property = { 
  internal_child       = {__type__="gchar*"},
};
-- GtkVBox如果带internal_child子属性，则不需要生成关联代码
Gtk224.GtkDialog["packing"] = {
  {
      -- 用于判断是否属于当前组
      group = {"internal_child"}, group_code = { { name = {"internal_child"}, can_skip = true, gen_code = ""}},
  },
};

--- 增加四个辅助类:
Gtk224.GtkDialogChildGtkVBox = {
  class = "GtkDialogChildGtkVBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_content_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_VBOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*"},
    information          = {__type__="gboolean"},
  },
  packing = {
    {
        group = {"internal_child"}, group_code = {
            -- 需要忽略掉这些packing属性的配置
            { name = {"internal_child"}, gen_code = ""},
            { name = {}, filter_out = {"expand", "fill", "pack_type", "padding", "position"}, can_skip = true, gen_code = ""} }
    },
    {
        -- 忽略掉pack_type与position
        group = {"information"}, group_code = { { name = {"information", "expand", "fill", "padding"}, filter_out = {"pack_type", "position"}, 
            gen_code = "gtk_box_pack_start((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}}
    },
  },
  parent = Gtk224.GtkVBox,
};
Gtk224.GtkDialogChildGtkBox = {
  class = "GtkDialogChildGtkBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_content_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_BOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*"},
    information          = {__type__="gboolean"},
  },
  packing = {
    {
        group = {"internal_child"}, group_code = { { name = {"internal_child"}, gen_code = ""}},
    },
    {
        group = {"information"}, group_code = { { name = {"information", "expand", "fill", "padding"}, 
            gen_code = "gtk_box_pack_start((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
        }
    },
  },
  parent = Gtk224.GtkBox,
};

Gtk224.GtkDialogChildGtkHButtonBox = {
  class = "GtkDialogChildGtkHButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_action_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_HBUTTON_BOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    response             = {__type__="gboolean"},
    dialog_id            = {__type__="GtkDialog*"},
  },
  packing = {
    {
        -- 用于判断是否属于当前组，"secondary"属性现在可以自动递归时处理了
        group = {"response", "dialog_id"},                  -- 需要忽略掉这些packing属性的配置
        group_code = { { name = {"response", "dialog_id"}, filter_out = {"expand", "fill", "pack_type", "padding", "position"},
            gen_code = "gtk_dialog_add_action_widget((GtkDialog*){* packing.dialog_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"},
        },
    },
  },
  parent = Gtk224.GtkHButtonBox,
};
Gtk224.GtkDialogChildGtkButtonBox = {
  class = "GtkDialogChildGtkButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_action_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_BUTTON_BOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    response             = {__type__="gboolean"},
    dialog_id            = {__type__="GtkDialog*"},
  },
  packing = {
    {
        -- 用于判断是否属于当前组，"secondary"属性现在可以自动递归时处理了
        group = {"response", "dialog_id"},                  -- 需要忽略掉这些packing属性的配置
        group_code = { { name = {"response", "dialog_id"}, filter_out = {"expand", "fill", "pack_type", "padding", "position"}, 
            gen_code = "gtk_dialog_add_action_widget((GtkDialog*){* packing.dialog_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"},
        },
    },
  },
  parent = Gtk224.GtkButtonBox,
};

----------------==  GtkFileChooserButton
-- 判断构造函数的顺序，new_with_dialog需要首先判断
Gtk224.GtkFileChooserButton.constructor.__sort__ = {
    "new_with_dialog", 
    "new_with_backend",
    "new"
};
Gtk224.GtkFileChooserButton.constructor.new_with_backend = { gencode = "gtk_file_chooser_button_new_with_backend((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.file_system_backend.value *}))",
                                           params = { type = {"const gchar*", "GtkFileChooserAction", "const gchar*"}, 
                                                    name = {"title", "action", "file_system_backend"}}};

----------------==  GtkFileChooserWidget
Gtk224.GtkFileChooserWidget.constructor.new_with_backend = { gencode = "gtk_file_chooser_button_new_with_backend((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.file_system_backend.value *}))",
                                            params = { type = {"GtkFileChooserAction", "const gchar*"}, 
                                                    name = {"action", "file_system_backend"}}};

----------------==  GtkFontButton
-- GtkFontButton的构建函数
Gtk224.GtkFontButton.constructor["new_with_font"] = { gencode = "gtk_font_button_new_with_font((const gchar*)({* this.font_name.value *}))",
												  params = { type = {"gchar*"}, name = {"font_name"} } };


----------------==  GtkFontSelection
----------------==  GtkGammaCurve
----------------==  GtkHButtonBox
----------------==  GtkInfoBar
Gtk224.GtkInfoBar.constructor.new_with_buttons = nil;
-- 子属性，用于区分packing
Gtk224.GtkInfoBar.child_property = { 
    -- 属性名称  属性类型 缺省值
    action_area    = {__type__="guint"},
    content_area   = {__type__="guint"},
    -- 这个响应ID，允许有默认值，为0
    response       = {__type__="guint"  ,__default__ = "0" },
};

-- 另外的构建属性则继承自Gtk224的GtkBox的packing属性
Gtk224.GtkInfoBar.packing = Gtk224.copy_and_insert_more(Gtk224.GtkBox.packing, -- Gtk224.GtkInfoBar.parent.packing,
    -- 添加其他的匹配关系
    {
        group = {"action_area", "response"}, group_code = { { name = {"action_area", "response"}, 
            gen_code = "gtk_info_bar_add_action_widget((GtkInfoBar*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"}
        }
    },
    {
        group = {"content_area"}, group_code = { { name = {"content_area", "expand", "fill", "padding"}, 
            gen_code = "gtk_box_pack_start((GtkBox*)gtk_info_bar_get_content_area({* id *}), (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
        }
    }
);

----------------==  GtkLinkButton
----------------==  GtkListItem
Gtk224.GtkListItem.constructor.new_with_label = nil;

----------------==  GtkMenuItem
-- GtkMenuItem的构建函数不需要修改，其params需要添加一项
Gtk224.GtkMenuItem.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use_underline"} };
-- GtkMenuItem的child property属性生成代码，在这里使用gtk_container_add
Gtk224.GtkMenuItem["packing"] = {
    {
        group = {}, group_code = { {name = {}, 
            gen_code = "gtk_menu_item_set_submenu((GtkMenuItem*)({* id *}), (GtkWidget*){* child.id.value *})"}}
    },
};
----------------==  GtkOffscreenWindow
----------------==  GtkOptionMenu
----------------==  GtkPlug
Gtk224.GtkPlug.constructor = {
    new             = { gencode = "gtk_plug_new((GdkWindow*)({* this.socket_window.value *}))",
                        params = { type = {"GdkWindow*"}, name = {"socket_window"} } }
};

----------------==  GtkRecentChooserMenu
--  GtkRecentChooserMenu ，属性来自于GtkRecentChooser
Gtk224.GtkRecentChooserMenu.constructor.new_for_manager = { gencode = "gtk_recent_chooser_menu_new_for_manager((GtkRecentManager*)({* this.recent_manager.value *}))", 
                                                    params = { type = {"GtkRecentManager*"}, name = {"recent_manager"} } };

----------------==  GtkRecentChooserWidget
--  GtkRecentChooserWidget ，属性来自于GtkRecentChooser
Gtk224.GtkRecentChooserWidget.constructor.new_for_manager = { gencode = "gtk_recent_chooser_widget_new_for_manager((GtkRecentManager*)({* this.recent_manager.value *}))", 
                                                    params = { type = {"GtkRecentManager*"}, name = {"recent_manager"} } };

----------------==  GtkScaleButton
Gtk224.GtkScaleButton.constructor.new = { gencode = "gtk_scale_button_new((GtkIconSize)({* this.size.value *}), (gdouble)(0), (gdouble)(0), (gdouble)(0), (const gchar**)(NULL))", 
                                          params = { type = {"GtkIconSize"}, 
                                                    name = {"size"} } };
Gtk224.GtkScaleButton.constructor.new_with_adj_icons = { gencode = "gtk_scale_button_new((GtkIconSize)({* this.size.value *}), (gdouble)gtk_adjustment_get_lower({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_upper({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_step_increment({* this.adjustment.value *}), (const gchar**)(NULL))", 
                                          params = { type = {"GtkIconSize", "GtkAdjustment*"}, 
                                                    name = {"size", "adjustment"} } };
Gtk224.GtkScaleButton.property.icons.__gencode__ = {"{ //",
                                                    "    const char* {* id *}_icons[] = { {* property.value *}, NULL}",
                                                    "    gtk_scale_button_set_icons((GtkScaleButton*)({* id *}), (const gchar**)({* id *}_icons))",
                                                    "} //"};
Gtk224.PatchGlibProperty(Gtk224.GtkScaleButton, {"size"});

----------------==  GtkSeparatorToolItem
----------------==  GtkStatusbar
----------------==  GtkToggleButton
-- GtkToggleButton需要增加draw_indicator的gencode属性
Gtk224.GtkToggleButton.constructor.new_with_mnemonic.params = {type = {"const gchar*", "gboolean"}, name = {"label", "use_underline"} };

Gtk224.GtkToggleButton.property["draw_indicator"]["__gencode__"] = {"gtk_toggle_button_set_mode((GtkToggleButton*){* id *}, (gboolean){* property.value *})"}

----------------==  GtkToolButton
----------------==  GtkVButtonBox
----------------==  GtkAboutDialog
Gtk224.GtkAboutDialog.property.artists.__gencode__ = {"{ //",
                                                      "    const char* {* id *}_artists[] = { {* property.value *}, NULL}",
                                                      "    gtk_about_dialog_set_artists((GtkAboutDialog*)({* id *}), (const gchar**)({* id *}_artists))",
                                                      "} //"};
Gtk224.GtkAboutDialog.property.authors.__gencode__ = {"{ //",
                                                      "    const char* {* id *}_authors[] = { {* property.value *}, NULL}",
                                                      "    gtk_about_dialog_set_authors((GtkAboutDialog*)({* id *}), (const gchar**)({* id *}_authors))",
                                                      "} //"};
Gtk224.GtkAboutDialog.property.documenters.__gencode__ = {"{ //",
                                                          "    const char* {* id *}_documenters[] = { {* property.value *}, NULL}",
                                                          "    gtk_about_dialog_set_documenters((GtkAboutDialog*)({* id *}), (const gchar**)({* id *}_documenters))",
                                                          "} //"};

----------------==  GtkCheckButton
Gtk224.GtkCheckButton.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use_underline"} };

----------------==  GtkCheckMenuItem
Gtk224.GtkCheckMenuItem.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use_underline"} };

----------------==  GtkColorSelectionDialog
--- 增加两个辅助类
Gtk224.GtkColorSelDlgButton = {
  class = "GtkColorSelDlgButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "GTK_GET_PROPERTY_WIDGET((GtkWidget*)({* parent.property.id.value *}), (const gchar*)({* this.internal_child.value *}))", 
            params = { type = {"const gchar*"}, name = {"internal_child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*", macro_code = {uiheaders = "COLOR_SEL_BUTTON_DEFINE", uisources = "GTK_GET_PROPERTY_WIDGET"}},
  },
  parent = Gtk224.GtkButton,
};
Gtk224.GtkColorSelectionInterChild = {
  class = "GtkColorSelectionInterChild", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_selection_dialog_get_color_selection((GtkColorSelectionDialog*)({* parent.property.id.value *}) )", 
            params = { type = {"const gchar*"}, name = {"internal_child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*", macro_code = {uiheaders = "COLOR_SEL_INTER_CHILD_DEFINE"}},
  },
  parent = Gtk224.GtkColorSelection,
};
-- 拷贝父类的父子关联
Gtk224.GtkColorSelectionDialog["packing"] = {
    {
        -- internal_child组，不需要建立父子关联
        group = {"internal_child"}, group_code = { {name = {"internal_child"}, can_skip = true, gen_code = ""}},
    },
    {
        -- 用于判断是否属于当前组
        group = {"response"}, group_code = {
            { name = {"response"}, 
              gen_code = "gtk_dialog_add_action_widget((GtkDialog*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"},
            { name = {"position"}, can_skip = true,
              gen_code = "gtk_box_reorder_child((GtkBox*)gtk_dialog_get_action_area((GtkDialog*){* id *}), (GtkWidget*){* child.id.value *}, {* packing.position.value *})"},
        },
    }, 
    {
        -- 用于判断是否属于当前组
        group = {"information"}, group_code = {
            { name = {"information", "expand", "fill", "padding"}, 
              gen_code = "gtk_box_pack_start((GtkBox*)gtk_dialog_get_content_area({* id *}), (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
        },
    },
};

----------------==  GtkFileChooserDialog
Gtk224.GtkFileChooserDialog.constructor.new.gencode = "gtk_file_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), NULL, 0)";
Gtk224.GtkFileChooserDialog.constructor.new_with_backend = { gencode = "gtk_file_chooser_button_new_with_backend((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.file_system_backend.value *}))",
                                            params = { type = {"const gchar*", "GtkWindow*", "GtkFileChooserAction", "const gchar*"}, 
                                                    name = {"title", "parent", "action", "file_system_backend"}}};

----------------==  GtkFileSelection
Gtk224.GtkFileSelection.property["show_fileops"]["__gencode__"] = {
    "if ({* property.value *})) {//",
    "    gtk_file_selection_show_fileop_buttons((GtkFileSelection*){* id *})",
    "} else {//",
    "    gtk_file_selection_hide_fileop_buttons((GtkFileSelection*){* id *})",
    "}//"
};

----------------==  GtkFontSelectionDialog
--- 增加两个辅助类
Gtk224.GtkFontSelDlgButton = {
  class = "GtkFontSelDlgButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_selection_dialog_get_{* this.internal_child.value *}((GtkFontSelectionDialog*)({* parent.property.id.value *}))", 
            params = { type = {"gint"}, name = {"internal_child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gint", macro_code = {uiheaders = "FONT_SEL_BUTTON_DEFINE"}},
  },
  parent = Gtk224.GtkButton,
};
Gtk224.GtkFontSelectionInterChild = {
  class = "GtkFontSelectionInterChild", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_selection_dialog_get_font_selection((GtkFontSelectionDialog*)({* parent.property.id.value *}) )", 
            params = { type = {"const gchar*"}, name = {"internal_child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*", macro_code = {uiheaders = "FONT_SEL_INTER_CHILD_DEFINE"}},
  },
  parent = Gtk224.GtkFontSelection,
};
Gtk224.GtkFontSelectionDialog["packing"] = Gtk224.GtkColorSelectionDialog["packing"];

----------------==  GtkImageMenuItem
-- 需要修改生成代码，且变更过滤器
Gtk224.GtkImageMenuItem.constructor.new_from_stock = {
    gencode = "gtk_image_menu_item_new_from_stock((const gchar*)({* this.label.value *}), (GtkAccelGroup*)({* this.accel_group.value *}))", 
    params = { type = {"const gchar*", "GtkAccelGroup*", "gboolean"}, 
               name = {"label", "accel_group", "use_stock"} } 
};
Gtk224.GtkImageMenuItem.constructor.new_from_stock2 = {
  gencode = "gtk_image_menu_item_new_from_stock((const gchar*)({* this.label.value *}), (GtkAccelGroup*)(NULL))", 
  params = { type = {"const gchar*", "gboolean"},  name = {"label", "use_stock"} } 
};
-- 不修改生成代码，只变更过滤器器
Gtk224.GtkImageMenuItem.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use_underline"} };
-- 判断构造函数的顺序
Gtk224.GtkImageMenuItem.constructor.__sort__ = {
  "new_from_stock", 
  "new_from_stock2", -- new_from_stock2必须在new_with_mnemonic之前
  "new_with_mnemonic",
  "new_with_label",
  "new"
};

----------------==  GtkInputDialog

----------------==  GtkMenuToolButton
----------------==  GtkMessageDialog
Gtk224.GtkMessageDialog.constructor = {
  -- 名称[- ==> _], 
  new             = { gencode = "gtk_message_dialog_new((GtkWindow*)(NULL), GTK_DIALOG_DESTROY_WITH_PARENT, (GtkMessageType)({* this.message_type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.text.value *}))", 
          params = { type = {"GtkMessageType", "GtkButtonsType", "gchar*"}, 
                      name = {"message_type", "buttons", "text"} } },
  new_with_markup = { gencode = "gtk_message_dialog_new_with_markup((GtkWindow*)(NULL), GTK_DIALOG_DESTROY_WITH_PARENT, (GtkMessageType)({* this.message_type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.text.value *}))", 
          params = { type = {"GtkWindow*", "GtkMessageType", "GtkButtonsType", "gchar*", "gboolean"}, 
                     name = {"message_type", "buttons", "text", "use_markup"} } },
};
Gtk224.PatchGlibProperty(Gtk224.GtkMessageDialog, {"use_markup", "secondary_text", "secondary_use_markup"});

----------------==  GtkRecentChooserDialog
Gtk224.GtkRecentChooserDialog.constructor.new.gencode = "gtk_recent_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (const gchar*)(NULL), 0)";
Gtk224.GtkRecentChooserDialog.constructor.new_for_manager = { gencode = "gtk_recent_chooser_dialog_new_for_manager((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkRecentManager*)({* this.manager.value *}), (const gchar*)(NULL), 0)", 
                                                              params = { type = {"const gchar*", "GtkWindow*", "GtkRecentManager*"}, 
                                                                        name = {"title", "parent", "manager"} } };

----------------==  GtkSeparatorMenuItem
----------------==  GtkTearoffMenuItem
----------------==  GtkToggleToolButton
----------------==  GtkVolumeButton
----------------==  GtkRadioButton
Gtk224.GtkRadioButton.property["group"]["__gencode__"]  = {"gtk_radio_button_set_group((GtkRadioButton*)({* id *}), (GSList*)gtk_radio_button_get_group({* property.value *}))"}

Gtk224.GtkRadioButton.constructor = {
  -- 名称[- ==> _],
  new                           = {gencode = "gtk_radio_button_new((GSList*)(0))", 
          params = { type = {}, 
                    name = {} } },
  new_from_widget              = { gencode = "gtk_radio_button_new_from_widget((GtkRadioButton*)({* this.group.value *}))",
          params = { type = {"GtkRadioButton*"},
                    name = {"group"} } },
  new_with_label                = { gencode = "gtk_radio_button_new_with_label((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*"},
                      name = {"label"} } },
  new_with_label_from_widget    = { gencode = "gtk_radio_button_new_with_label_from_widget((GtkRadioButton*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioButton*", "const gchar*"},
                     name = {"group", "label"} } },
  new_with_mnemonic             = { gencode = "gtk_radio_button_new_with_mnemonic((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*", "gboolean"},
                    name = {"label", "use_underline"}} },
  new_with_mnemonic_from_widget = { gencode = "gtk_radio_button_new_with_mnemonic_from_widget((GtkRadioButton*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioButton*", "const gchar*", "gboolean"},
                     name = {"group", "label", "use_underline"}} },
};

----------------==  GtkRadioMenuItem
Gtk224.GtkRadioMenuItem.property["group"]["__gencode__"]  = {"gtk_radio_menu_item_set_group((GtkRadioMenuItem*)({* id *}), (GSList*)gtk_radio_menu_item_get_group({* property.value *}))"}

Gtk224.GtkRadioMenuItem.constructor = {
  -- 名称[- ==> _],
  new                           = {gencode = "gtk_radio_menu_item_new((GSList*)(0))", 
          params = { type = {}, 
                    name = {} } },
  new_from_widget              = { gencode = "gtk_radio_menu_item_new_from_widget((GtkRadioMenuItem*)({* this.group.value *}))",
          params = { type = {"GtkRadioMenuItem*"},
                    name = {"group"} } },
  new_with_label                = { gencode = "gtk_radio_menu_item_new_with_label((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*"},
                      name = {"label"} } },
  new_with_label_from_widget    = { gencode = "gtk_radio_menu_item_new_with_label_from_widget((GtkRadioMenuItem*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioMenuItem*", "const gchar*"},
                     name = {"group", "label"} } },
  new_with_mnemonic             = { gencode = "gtk_radio_menu_item_new_with_mnemonic((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*", "gboolean"},
                    name = {"label", "use_underline"}} },
  new_with_mnemonic_from_widget = { gencode = "gtk_radio_menu_item_new_with_mnemonic_from_widget((GtkRadioMenuItem*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioMenuItem*", "const gchar*", "gboolean"},
                     name = {"group", "label", "use_underline"}} },
};

----------------==  GtkRadioToolButton
Gtk224.GtkRadioToolButton.property["group"]["__gencode__"]  = {"gtk_radio_tool_button_set_group((GtkRadioToolButton*)({* id *}), (GSList*)gtk_radio_tool_button_get_group({* property.value *}))"}

Gtk224.GtkRadioToolButton.constructor = {
  -- 名称[- ==> _],
  new                            = {gencode = "gtk_radio_tool_button_new((GSList*)(0))", 
          params = { type = {}, 
                    name = {} } },
  new_from_stock                 = { gencode = "gtk_radio_tool_button_new_from_stock((GSList*)(0), (const gchar*)({* this.stock_id.value *}))",
          params = { type = {"const gchar*"},
                    name = {"stock_id"} } },
  new_from_widget                = { gencode = "gtk_radio_tool_button_new_from_widget((GtkRadioToolButton*)({* this.group.value *}))",
          params = { type = {"GtkRadioToolButton*"},
                      name = {"group"} } },
  new_with_stock_from_widget     = { gencode = "gtk_radio_tool_button_new_with_stock_from_widget((GtkRadioToolButton*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioToolButton*", "const gchar*"},
                     name = {"group", "stock_id"} } },
};

----------------========================

---------------------  GtkTmplWidget示例，所有的模板类都格式与这个类相同，用于生成模板类的代码
--[[
Gtk224.GtkTmplWidget = {
  class = "GtkTmplWidget",
  constructor = {
    -- 名称[- ==> _], 
    new = { gencode = "TMPL_WIDGET({* id *})", 
            params = { type = {}, name = {} } },
  },
  signal = {
      -- 信号名称[- ==> _]， 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    __parent_class__ = {__type__="gchar*" ,  __default__ = "NULL", __gencode__ = ""},
  },
  parent = nil,
};
]]--

------------------------  属性补丁，如下属性，依赖顶层控件，需要增加一个属性
Gtk224.GtkActivatable.property.related_action.is_top_widget = true;
Gtk224.GtkEntryCompletion.property.model.is_top_widget = true;
Gtk224.GtkPrintOperation.property.default_page_setup.is_top_widget = true;
Gtk224.GtkPrintOperation.property.print_settings.is_top_widget = true;
Gtk224.GtkTextBuffer.property.tag_table.is_top_widget = true;
Gtk224.GtkTreeModelSort.property.model.is_top_widget = true;
Gtk224.GtkRadioAction.property.group.is_top_widget = true;
Gtk224.GtkCellRendererCombo.property.model.is_top_widget = true;
Gtk224.GtkCellRendererSpin.property.adjustment.is_top_widget = true;
Gtk224.GtkIconView.property.model.is_top_widget = true;
Gtk224.GtkLayout.property.hadjustment.is_top_widget = true;
Gtk224.GtkLayout.property.vadjustment.is_top_widget = true;
Gtk224.GtkProgressBar.property.adjustment.is_top_widget = true;
Gtk224.GtkSpinButton.property.adjustment.is_top_widget = true;
Gtk224.GtkTextView.property.buffer.is_top_widget = true;
Gtk224.GtkTreeView.property.expander_column.is_top_widget = true;
Gtk224.GtkTreeView.property.hadjustment.is_top_widget = true;
Gtk224.GtkTreeView.property.model.is_top_widget = true;
Gtk224.GtkTreeView.property.vadjustment.is_top_widget = true;
Gtk224.GtkComboBox.property.model.is_top_widget = true;
Gtk224.GtkScrolledWindow.property.hadjustment.is_top_widget = true;
Gtk224.GtkScrolledWindow.property.vadjustment.is_top_widget = true;
Gtk224.GtkViewport.property.hadjustment.is_top_widget = true;
Gtk224.GtkViewport.property.vadjustment.is_top_widget = true;
Gtk224.GtkFileChooserButton.property.dialog.is_top_widget = true;
Gtk224.GtkScaleButton.property.adjustment.is_top_widget = true;
Gtk224.GtkEntry.property.buffer.is_top_widget = true;
Gtk224.GtkFileChooser.property.filter.is_top_widget = true;

-- 增加ext_depend属性，表示该属性需要依赖其他控件（有可能是顶层控件，也有可能是其他子控件）
Gtk224.GtkActivatable.property.related_action.ext_depend = true;
Gtk224.GtkEntryCompletion.property.model.ext_depend = true;
Gtk224.GtkPrintOperation.property.default_page_setup.ext_depend = true;
Gtk224.GtkPrintOperation.property.print_settings.ext_depend = true;
Gtk224.GtkTextBuffer.property.tag_table.ext_depend = true;
Gtk224.GtkTreeModelSort.property.model.ext_depend = true;
Gtk224.GtkRadioAction.property.group.ext_depend = true;
Gtk224.GtkCellRendererCombo.property.model.ext_depend = true;
Gtk224.GtkCellRendererSpin.property.adjustment.ext_depend = true;
Gtk224.GtkIconView.property.model.ext_depend = true;
Gtk224.GtkLayout.property.hadjustment.ext_depend = true;
Gtk224.GtkLayout.property.vadjustment.ext_depend = true;
Gtk224.GtkProgressBar.property.adjustment.ext_depend = true;
Gtk224.GtkSpinButton.property.adjustment.ext_depend = true;
Gtk224.GtkTextView.property.buffer.ext_depend = true;
Gtk224.GtkTreeView.property.expander_column.ext_depend = true;
Gtk224.GtkTreeView.property.hadjustment.ext_depend = true;
Gtk224.GtkTreeView.property.model.ext_depend = true;
Gtk224.GtkTreeView.property.vadjustment.ext_depend = true;
Gtk224.GtkComboBox.property.model.ext_depend = true;
Gtk224.GtkScrolledWindow.property.hadjustment.ext_depend = true;
Gtk224.GtkScrolledWindow.property.vadjustment.ext_depend = true;
Gtk224.GtkViewport.property.hadjustment.ext_depend = true;
Gtk224.GtkViewport.property.vadjustment.ext_depend = true;
Gtk224.GtkFileChooserButton.property.dialog.ext_depend = true;
Gtk224.GtkScaleButton.property.adjustment.ext_depend = true;
Gtk224.GtkEntry.property.buffer.ext_depend = true;
Gtk224.GtkFileChooser.property.filter.ext_depend = true;

------------------------  属性补丁，如下属性，生成的代码中，需要在所有函数声明前增加一个统一的补丁函数
Gtk224.GtkActivatable.property.related_action.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkEntryCompletion.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkPrintOperation.property.default_page_setup.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkPrintOperation.property.print_settings.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTextBuffer.property.tag_table.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTreeModelSort.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkRadioAction.property.group.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkCellRendererCombo.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkCellRendererSpin.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkIconView.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkLayout.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkLayout.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkProgressBar.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkSpinButton.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTextView.property.buffer.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTreeView.property.expander_column.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTreeView.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTreeView.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkTreeView.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkComboBox.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkScrolledWindow.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkScrolledWindow.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkViewport.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkViewport.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkFileChooserButton.property.dialog.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkScaleButton.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk224.GtkFileChooser.property.filter.macro_code = {uisources = "TOP_WIDGET"};

Gtk224.GtkTextTag.property.background_gdk.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkTextTag.property.foreground_gdk.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkTextTag.property.paragraph_background_gdk.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkCellRenderer.property.cell_background_gdk.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkCellRendererText.property.background_gdk.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkCellRendererText.property.foreground_gdk.macro_code = {uisources = "GDK_COLOR"};
-- 这个允许为NULL
Gtk224.GtkCellView.property.background.macro_code = {uisources = "GDK_COLOR2"};
Gtk224.GtkCellView.property.background_gdk.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkColorButton.property.color.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkColorButton.property.color.macro_code = {uisources = "GDK_COLOR"};
Gtk224.GtkColorSelection.property.current_color.macro_code = {uisources = "GDK_COLOR"};

Gtk224.GtkEntry.property.buffer.macro_code = {uisources = "TOP_WIDGET"};

Gtk224.GtkStatusIcon.property.pixbuf.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkCellRendererPixbuf.property.pixbuf.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkCellRendererPixbuf.property.pixbuf_expander_closed.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkCellRendererPixbuf.property.pixbuf_expander_open.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkEntry.property["primary_icon_pixbuf"]["macro_code"] = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkEntry.property["secondary_icon_pixbuf"]["macro_code"] = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkImage.property.pixbuf.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkWindow.property.icon.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkAssistant.child_property.header_image.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkAssistant.child_property.sidebar_image.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk224.GtkAboutDialog.property.logo.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};

---- 末尾处，表的拷贝函数不再需要了
Gtk224.PatchGlibProperty = nil;
Gtk224.insert_more = nil;
Gtk224.copy_and_insert_more = nil;
Gtk224.table_copy_table_in_patch = nil;
